-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gio.Callbacks
    ( 

 -- * Signals


-- ** ActionEntryActivateFieldCallback #signal:ActionEntryActivateFieldCallback#

    ActionEntryActivateFieldCallback        ,
    ActionEntryActivateFieldCallback_WithClosures,
    C_ActionEntryActivateFieldCallback      ,
    drop_closures_ActionEntryActivateFieldCallback,
    dynamic_ActionEntryActivateFieldCallback,
    genClosure_ActionEntryActivateFieldCallback,
    mk_ActionEntryActivateFieldCallback     ,
    noActionEntryActivateFieldCallback      ,
    noActionEntryActivateFieldCallback_WithClosures,
    wrap_ActionEntryActivateFieldCallback   ,


-- ** ActionEntryChangeStateFieldCallback #signal:ActionEntryChangeStateFieldCallback#

    ActionEntryChangeStateFieldCallback     ,
    ActionEntryChangeStateFieldCallback_WithClosures,
    C_ActionEntryChangeStateFieldCallback   ,
    drop_closures_ActionEntryChangeStateFieldCallback,
    dynamic_ActionEntryChangeStateFieldCallback,
    genClosure_ActionEntryChangeStateFieldCallback,
    mk_ActionEntryChangeStateFieldCallback  ,
    noActionEntryChangeStateFieldCallback   ,
    noActionEntryChangeStateFieldCallback_WithClosures,
    wrap_ActionEntryChangeStateFieldCallback,


-- ** AsyncReadyCallback #signal:AsyncReadyCallback#

    AsyncReadyCallback                      ,
    AsyncReadyCallback_WithClosures         ,
    C_AsyncReadyCallback                    ,
    drop_closures_AsyncReadyCallback        ,
    dynamic_AsyncReadyCallback              ,
    genClosure_AsyncReadyCallback           ,
    mk_AsyncReadyCallback                   ,
    noAsyncReadyCallback                    ,
    noAsyncReadyCallback_WithClosures       ,
    wrap_AsyncReadyCallback                 ,


-- ** BusAcquiredCallback #signal:BusAcquiredCallback#

    BusAcquiredCallback                     ,
    BusAcquiredCallback_WithClosures        ,
    C_BusAcquiredCallback                   ,
    drop_closures_BusAcquiredCallback       ,
    dynamic_BusAcquiredCallback             ,
    genClosure_BusAcquiredCallback          ,
    mk_BusAcquiredCallback                  ,
    noBusAcquiredCallback                   ,
    noBusAcquiredCallback_WithClosures      ,
    wrap_BusAcquiredCallback                ,


-- ** BusNameAcquiredCallback #signal:BusNameAcquiredCallback#

    BusNameAcquiredCallback                 ,
    BusNameAcquiredCallback_WithClosures    ,
    C_BusNameAcquiredCallback               ,
    drop_closures_BusNameAcquiredCallback   ,
    dynamic_BusNameAcquiredCallback         ,
    genClosure_BusNameAcquiredCallback      ,
    mk_BusNameAcquiredCallback              ,
    noBusNameAcquiredCallback               ,
    noBusNameAcquiredCallback_WithClosures  ,
    wrap_BusNameAcquiredCallback            ,


-- ** BusNameAppearedCallback #signal:BusNameAppearedCallback#

    BusNameAppearedCallback                 ,
    BusNameAppearedCallback_WithClosures    ,
    C_BusNameAppearedCallback               ,
    drop_closures_BusNameAppearedCallback   ,
    dynamic_BusNameAppearedCallback         ,
    genClosure_BusNameAppearedCallback      ,
    mk_BusNameAppearedCallback              ,
    noBusNameAppearedCallback               ,
    noBusNameAppearedCallback_WithClosures  ,
    wrap_BusNameAppearedCallback            ,


-- ** BusNameLostCallback #signal:BusNameLostCallback#

    BusNameLostCallback                     ,
    BusNameLostCallback_WithClosures        ,
    C_BusNameLostCallback                   ,
    drop_closures_BusNameLostCallback       ,
    dynamic_BusNameLostCallback             ,
    genClosure_BusNameLostCallback          ,
    mk_BusNameLostCallback                  ,
    noBusNameLostCallback                   ,
    noBusNameLostCallback_WithClosures      ,
    wrap_BusNameLostCallback                ,


-- ** BusNameVanishedCallback #signal:BusNameVanishedCallback#

    BusNameVanishedCallback                 ,
    BusNameVanishedCallback_WithClosures    ,
    C_BusNameVanishedCallback               ,
    drop_closures_BusNameVanishedCallback   ,
    dynamic_BusNameVanishedCallback         ,
    genClosure_BusNameVanishedCallback      ,
    mk_BusNameVanishedCallback              ,
    noBusNameVanishedCallback               ,
    noBusNameVanishedCallback_WithClosures  ,
    wrap_BusNameVanishedCallback            ,


-- ** CancellableSourceFunc #signal:CancellableSourceFunc#

    C_CancellableSourceFunc                 ,
    CancellableSourceFunc                   ,
    dynamic_CancellableSourceFunc           ,
    genClosure_CancellableSourceFunc        ,
    mk_CancellableSourceFunc                ,
    noCancellableSourceFunc                 ,
    wrap_CancellableSourceFunc              ,


-- ** DBusInterfaceGetPropertyFunc #signal:DBusInterfaceGetPropertyFunc#

    C_DBusInterfaceGetPropertyFunc          ,
    DBusInterfaceGetPropertyFunc            ,
    DBusInterfaceGetPropertyFunc_WithClosures,
    drop_closures_DBusInterfaceGetPropertyFunc,
    dynamic_DBusInterfaceGetPropertyFunc    ,
    genClosure_DBusInterfaceGetPropertyFunc ,
    mk_DBusInterfaceGetPropertyFunc         ,
    noDBusInterfaceGetPropertyFunc          ,
    noDBusInterfaceGetPropertyFunc_WithClosures,
    wrap_DBusInterfaceGetPropertyFunc       ,


-- ** DBusInterfaceMethodCallFunc #signal:DBusInterfaceMethodCallFunc#

    C_DBusInterfaceMethodCallFunc           ,
    DBusInterfaceMethodCallFunc             ,
    DBusInterfaceMethodCallFunc_WithClosures,
    drop_closures_DBusInterfaceMethodCallFunc,
    dynamic_DBusInterfaceMethodCallFunc     ,
    genClosure_DBusInterfaceMethodCallFunc  ,
    mk_DBusInterfaceMethodCallFunc          ,
    noDBusInterfaceMethodCallFunc           ,
    noDBusInterfaceMethodCallFunc_WithClosures,
    wrap_DBusInterfaceMethodCallFunc        ,


-- ** DBusInterfaceSetPropertyFunc #signal:DBusInterfaceSetPropertyFunc#

    C_DBusInterfaceSetPropertyFunc          ,
    DBusInterfaceSetPropertyFunc            ,
    DBusInterfaceSetPropertyFunc_WithClosures,
    drop_closures_DBusInterfaceSetPropertyFunc,
    dynamic_DBusInterfaceSetPropertyFunc    ,
    genClosure_DBusInterfaceSetPropertyFunc ,
    mk_DBusInterfaceSetPropertyFunc         ,
    noDBusInterfaceSetPropertyFunc          ,
    noDBusInterfaceSetPropertyFunc_WithClosures,
    wrap_DBusInterfaceSetPropertyFunc       ,


-- ** DBusMessageFilterFunction #signal:DBusMessageFilterFunction#

    C_DBusMessageFilterFunction             ,
    DBusMessageFilterFunction               ,
    DBusMessageFilterFunction_WithClosures  ,
    drop_closures_DBusMessageFilterFunction ,
    dynamic_DBusMessageFilterFunction       ,
    genClosure_DBusMessageFilterFunction    ,
    mk_DBusMessageFilterFunction            ,
    noDBusMessageFilterFunction             ,
    noDBusMessageFilterFunction_WithClosures,
    wrap_DBusMessageFilterFunction          ,


-- ** DBusProxyTypeFunc #signal:DBusProxyTypeFunc#

    C_DBusProxyTypeFunc                     ,
    DBusProxyTypeFunc                       ,
    dynamic_DBusProxyTypeFunc               ,
    genClosure_DBusProxyTypeFunc            ,
    mk_DBusProxyTypeFunc                    ,
    noDBusProxyTypeFunc                     ,
    wrap_DBusProxyTypeFunc                  ,


-- ** DBusSignalCallback #signal:DBusSignalCallback#

    C_DBusSignalCallback                    ,
    DBusSignalCallback                      ,
    DBusSignalCallback_WithClosures         ,
    drop_closures_DBusSignalCallback        ,
    dynamic_DBusSignalCallback              ,
    genClosure_DBusSignalCallback           ,
    mk_DBusSignalCallback                   ,
    noDBusSignalCallback                    ,
    noDBusSignalCallback_WithClosures       ,
    wrap_DBusSignalCallback                 ,


-- ** DBusSubtreeDispatchFunc #signal:DBusSubtreeDispatchFunc#

    C_DBusSubtreeDispatchFunc               ,
    DBusSubtreeDispatchFunc                 ,
    DBusSubtreeDispatchFunc_WithClosures    ,
    drop_closures_DBusSubtreeDispatchFunc   ,
    dynamic_DBusSubtreeDispatchFunc         ,
    genClosure_DBusSubtreeDispatchFunc      ,
    mk_DBusSubtreeDispatchFunc              ,
    noDBusSubtreeDispatchFunc               ,
    noDBusSubtreeDispatchFunc_WithClosures  ,
    wrap_DBusSubtreeDispatchFunc            ,


-- ** DBusSubtreeEnumerateFunc #signal:DBusSubtreeEnumerateFunc#

    C_DBusSubtreeEnumerateFunc              ,
    DBusSubtreeEnumerateFunc                ,
    DBusSubtreeEnumerateFunc_WithClosures   ,
    drop_closures_DBusSubtreeEnumerateFunc  ,
    dynamic_DBusSubtreeEnumerateFunc        ,
    genClosure_DBusSubtreeEnumerateFunc     ,
    mk_DBusSubtreeEnumerateFunc             ,
    noDBusSubtreeEnumerateFunc              ,
    noDBusSubtreeEnumerateFunc_WithClosures ,
    wrap_DBusSubtreeEnumerateFunc           ,


-- ** DBusSubtreeIntrospectFunc #signal:DBusSubtreeIntrospectFunc#

    C_DBusSubtreeIntrospectFunc             ,
    DBusSubtreeIntrospectFunc               ,
    DBusSubtreeIntrospectFunc_WithClosures  ,
    drop_closures_DBusSubtreeIntrospectFunc ,
    dynamic_DBusSubtreeIntrospectFunc       ,
    genClosure_DBusSubtreeIntrospectFunc    ,
    mk_DBusSubtreeIntrospectFunc            ,
    noDBusSubtreeIntrospectFunc             ,
    noDBusSubtreeIntrospectFunc_WithClosures,
    wrap_DBusSubtreeIntrospectFunc          ,


-- ** DatagramBasedSourceFunc #signal:DatagramBasedSourceFunc#

    C_DatagramBasedSourceFunc               ,
    DatagramBasedSourceFunc                 ,
    dynamic_DatagramBasedSourceFunc         ,
    genClosure_DatagramBasedSourceFunc      ,
    mk_DatagramBasedSourceFunc              ,
    noDatagramBasedSourceFunc               ,
    wrap_DatagramBasedSourceFunc            ,


-- ** DesktopAppLaunchCallback #signal:DesktopAppLaunchCallback#

    C_DesktopAppLaunchCallback              ,
    DesktopAppLaunchCallback                ,
    DesktopAppLaunchCallback_WithClosures   ,
    drop_closures_DesktopAppLaunchCallback  ,
    dynamic_DesktopAppLaunchCallback        ,
    genClosure_DesktopAppLaunchCallback     ,
    mk_DesktopAppLaunchCallback             ,
    noDesktopAppLaunchCallback              ,
    noDesktopAppLaunchCallback_WithClosures ,
    wrap_DesktopAppLaunchCallback           ,


-- ** FileMeasureProgressCallback #signal:FileMeasureProgressCallback#

    C_FileMeasureProgressCallback           ,
    FileMeasureProgressCallback             ,
    dynamic_FileMeasureProgressCallback     ,
    genClosure_FileMeasureProgressCallback  ,
    mk_FileMeasureProgressCallback          ,
    noFileMeasureProgressCallback           ,
    wrap_FileMeasureProgressCallback        ,


-- ** FileProgressCallback #signal:FileProgressCallback#

    C_FileProgressCallback                  ,
    FileProgressCallback                    ,
    dynamic_FileProgressCallback            ,
    genClosure_FileProgressCallback         ,
    mk_FileProgressCallback                 ,
    noFileProgressCallback                  ,
    wrap_FileProgressCallback               ,


-- ** FileReadMoreCallback #signal:FileReadMoreCallback#

    C_FileReadMoreCallback                  ,
    FileReadMoreCallback                    ,
    dynamic_FileReadMoreCallback            ,
    genClosure_FileReadMoreCallback         ,
    mk_FileReadMoreCallback                 ,
    noFileReadMoreCallback                  ,
    wrap_FileReadMoreCallback               ,


-- ** IOSchedulerJobFunc #signal:IOSchedulerJobFunc#

    C_IOSchedulerJobFunc                    ,
    IOSchedulerJobFunc                      ,
    dynamic_IOSchedulerJobFunc              ,
    genClosure_IOSchedulerJobFunc           ,
    mk_IOSchedulerJobFunc                   ,
    noIOSchedulerJobFunc                    ,
    wrap_IOSchedulerJobFunc                 ,


-- ** InputStreamClassCloseAsyncFieldCallback #signal:InputStreamClassCloseAsyncFieldCallback#

    C_InputStreamClassCloseAsyncFieldCallback,
    InputStreamClassCloseAsyncFieldCallback ,
    InputStreamClassCloseAsyncFieldCallback_WithClosures,
    drop_closures_InputStreamClassCloseAsyncFieldCallback,
    dynamic_InputStreamClassCloseAsyncFieldCallback,
    genClosure_InputStreamClassCloseAsyncFieldCallback,
    mk_InputStreamClassCloseAsyncFieldCallback,
    noInputStreamClassCloseAsyncFieldCallback,
    noInputStreamClassCloseAsyncFieldCallback_WithClosures,
    wrap_InputStreamClassCloseAsyncFieldCallback,


-- ** InputStreamClassCloseFinishFieldCallback #signal:InputStreamClassCloseFinishFieldCallback#

    C_InputStreamClassCloseFinishFieldCallback,
    InputStreamClassCloseFinishFieldCallback,
    dynamic_InputStreamClassCloseFinishFieldCallback,
    mk_InputStreamClassCloseFinishFieldCallback,
    noInputStreamClassCloseFinishFieldCallback,


-- ** InputStreamClassCloseFnFieldCallback #signal:InputStreamClassCloseFnFieldCallback#

    C_InputStreamClassCloseFnFieldCallback  ,
    InputStreamClassCloseFnFieldCallback    ,
    dynamic_InputStreamClassCloseFnFieldCallback,
    mk_InputStreamClassCloseFnFieldCallback ,
    noInputStreamClassCloseFnFieldCallback  ,


-- ** InputStreamClassReadAsyncFieldCallback #signal:InputStreamClassReadAsyncFieldCallback#

    C_InputStreamClassReadAsyncFieldCallback,
    InputStreamClassReadAsyncFieldCallback  ,
    InputStreamClassReadAsyncFieldCallback_WithClosures,
    drop_closures_InputStreamClassReadAsyncFieldCallback,
    dynamic_InputStreamClassReadAsyncFieldCallback,
    genClosure_InputStreamClassReadAsyncFieldCallback,
    mk_InputStreamClassReadAsyncFieldCallback,
    noInputStreamClassReadAsyncFieldCallback,
    noInputStreamClassReadAsyncFieldCallback_WithClosures,
    wrap_InputStreamClassReadAsyncFieldCallback,


-- ** InputStreamClassReadFinishFieldCallback #signal:InputStreamClassReadFinishFieldCallback#

    C_InputStreamClassReadFinishFieldCallback,
    InputStreamClassReadFinishFieldCallback ,
    dynamic_InputStreamClassReadFinishFieldCallback,
    mk_InputStreamClassReadFinishFieldCallback,
    noInputStreamClassReadFinishFieldCallback,


-- ** InputStreamClassReadFnFieldCallback #signal:InputStreamClassReadFnFieldCallback#

    C_InputStreamClassReadFnFieldCallback   ,
    InputStreamClassReadFnFieldCallback     ,
    dynamic_InputStreamClassReadFnFieldCallback,
    mk_InputStreamClassReadFnFieldCallback  ,
    noInputStreamClassReadFnFieldCallback   ,


-- ** InputStreamClassSkipAsyncFieldCallback #signal:InputStreamClassSkipAsyncFieldCallback#

    C_InputStreamClassSkipAsyncFieldCallback,
    InputStreamClassSkipAsyncFieldCallback  ,
    InputStreamClassSkipAsyncFieldCallback_WithClosures,
    drop_closures_InputStreamClassSkipAsyncFieldCallback,
    dynamic_InputStreamClassSkipAsyncFieldCallback,
    genClosure_InputStreamClassSkipAsyncFieldCallback,
    mk_InputStreamClassSkipAsyncFieldCallback,
    noInputStreamClassSkipAsyncFieldCallback,
    noInputStreamClassSkipAsyncFieldCallback_WithClosures,
    wrap_InputStreamClassSkipAsyncFieldCallback,


-- ** InputStreamClassSkipFieldCallback #signal:InputStreamClassSkipFieldCallback#

    C_InputStreamClassSkipFieldCallback     ,
    InputStreamClassSkipFieldCallback       ,
    dynamic_InputStreamClassSkipFieldCallback,
    mk_InputStreamClassSkipFieldCallback    ,
    noInputStreamClassSkipFieldCallback     ,


-- ** InputStreamClassSkipFinishFieldCallback #signal:InputStreamClassSkipFinishFieldCallback#

    C_InputStreamClassSkipFinishFieldCallback,
    InputStreamClassSkipFinishFieldCallback ,
    dynamic_InputStreamClassSkipFinishFieldCallback,
    mk_InputStreamClassSkipFinishFieldCallback,
    noInputStreamClassSkipFinishFieldCallback,


-- ** PollableSourceFunc #signal:PollableSourceFunc#

    C_PollableSourceFunc                    ,
    PollableSourceFunc                      ,
    dynamic_PollableSourceFunc              ,
    genClosure_PollableSourceFunc           ,
    mk_PollableSourceFunc                   ,
    noPollableSourceFunc                    ,
    wrap_PollableSourceFunc                 ,


-- ** ReallocFunc #signal:ReallocFunc#

    C_ReallocFunc                           ,
    ReallocFunc                             ,
    dynamic_ReallocFunc                     ,
    genClosure_ReallocFunc                  ,
    mk_ReallocFunc                          ,
    noReallocFunc                           ,
    wrap_ReallocFunc                        ,


-- ** SeekableIfaceCanSeekFieldCallback #signal:SeekableIfaceCanSeekFieldCallback#

    C_SeekableIfaceCanSeekFieldCallback     ,
    SeekableIfaceCanSeekFieldCallback       ,
    dynamic_SeekableIfaceCanSeekFieldCallback,
    genClosure_SeekableIfaceCanSeekFieldCallback,
    mk_SeekableIfaceCanSeekFieldCallback    ,
    noSeekableIfaceCanSeekFieldCallback     ,
    wrap_SeekableIfaceCanSeekFieldCallback  ,


-- ** SeekableIfaceCanTruncateFieldCallback #signal:SeekableIfaceCanTruncateFieldCallback#

    C_SeekableIfaceCanTruncateFieldCallback ,
    SeekableIfaceCanTruncateFieldCallback   ,
    dynamic_SeekableIfaceCanTruncateFieldCallback,
    genClosure_SeekableIfaceCanTruncateFieldCallback,
    mk_SeekableIfaceCanTruncateFieldCallback,
    noSeekableIfaceCanTruncateFieldCallback ,
    wrap_SeekableIfaceCanTruncateFieldCallback,


-- ** SeekableIfaceSeekFieldCallback #signal:SeekableIfaceSeekFieldCallback#

    C_SeekableIfaceSeekFieldCallback        ,
    SeekableIfaceSeekFieldCallback          ,
    dynamic_SeekableIfaceSeekFieldCallback  ,
    mk_SeekableIfaceSeekFieldCallback       ,
    noSeekableIfaceSeekFieldCallback        ,


-- ** SeekableIfaceTellFieldCallback #signal:SeekableIfaceTellFieldCallback#

    C_SeekableIfaceTellFieldCallback        ,
    SeekableIfaceTellFieldCallback          ,
    dynamic_SeekableIfaceTellFieldCallback  ,
    genClosure_SeekableIfaceTellFieldCallback,
    mk_SeekableIfaceTellFieldCallback       ,
    noSeekableIfaceTellFieldCallback        ,
    wrap_SeekableIfaceTellFieldCallback     ,


-- ** SeekableIfaceTruncateFnFieldCallback #signal:SeekableIfaceTruncateFnFieldCallback#

    C_SeekableIfaceTruncateFnFieldCallback  ,
    SeekableIfaceTruncateFnFieldCallback    ,
    dynamic_SeekableIfaceTruncateFnFieldCallback,
    mk_SeekableIfaceTruncateFnFieldCallback ,
    noSeekableIfaceTruncateFnFieldCallback  ,


-- ** SettingsBindGetMapping #signal:SettingsBindGetMapping#

    C_SettingsBindGetMapping                ,
    SettingsBindGetMapping                  ,
    SettingsBindGetMapping_WithClosures     ,
    drop_closures_SettingsBindGetMapping    ,
    dynamic_SettingsBindGetMapping          ,
    genClosure_SettingsBindGetMapping       ,
    mk_SettingsBindGetMapping               ,
    noSettingsBindGetMapping                ,
    noSettingsBindGetMapping_WithClosures   ,
    wrap_SettingsBindGetMapping             ,


-- ** SettingsBindSetMapping #signal:SettingsBindSetMapping#

    C_SettingsBindSetMapping                ,
    SettingsBindSetMapping                  ,
    SettingsBindSetMapping_WithClosures     ,
    drop_closures_SettingsBindSetMapping    ,
    dynamic_SettingsBindSetMapping          ,
    genClosure_SettingsBindSetMapping       ,
    mk_SettingsBindSetMapping               ,
    noSettingsBindSetMapping                ,
    noSettingsBindSetMapping_WithClosures   ,
    wrap_SettingsBindSetMapping             ,


-- ** SettingsGetMapping #signal:SettingsGetMapping#

    C_SettingsGetMapping                    ,
    SettingsGetMapping                      ,
    SettingsGetMapping_WithClosures         ,
    drop_closures_SettingsGetMapping        ,
    dynamic_SettingsGetMapping              ,
    genClosure_SettingsGetMapping           ,
    mk_SettingsGetMapping                   ,
    noSettingsGetMapping                    ,
    noSettingsGetMapping_WithClosures       ,
    wrap_SettingsGetMapping                 ,


-- ** SimpleAsyncThreadFunc #signal:SimpleAsyncThreadFunc#

    C_SimpleAsyncThreadFunc                 ,
    SimpleAsyncThreadFunc                   ,
    dynamic_SimpleAsyncThreadFunc           ,
    genClosure_SimpleAsyncThreadFunc        ,
    mk_SimpleAsyncThreadFunc                ,
    noSimpleAsyncThreadFunc                 ,
    wrap_SimpleAsyncThreadFunc              ,


-- ** SocketSourceFunc #signal:SocketSourceFunc#

    C_SocketSourceFunc                      ,
    SocketSourceFunc                        ,
    dynamic_SocketSourceFunc                ,
    genClosure_SocketSourceFunc             ,
    mk_SocketSourceFunc                     ,
    noSocketSourceFunc                      ,
    wrap_SocketSourceFunc                   ,


-- ** TaskThreadFunc #signal:TaskThreadFunc#

    C_TaskThreadFunc                        ,
    TaskThreadFunc                          ,
    dynamic_TaskThreadFunc                  ,
    genClosure_TaskThreadFunc               ,
    mk_TaskThreadFunc                       ,
    noTaskThreadFunc                        ,
    wrap_TaskThreadFunc                     ,


-- ** VfsFileLookupFunc #signal:VfsFileLookupFunc#

    C_VfsFileLookupFunc                     ,
    VfsFileLookupFunc                       ,
    VfsFileLookupFunc_WithClosures          ,
    drop_closures_VfsFileLookupFunc         ,
    dynamic_VfsFileLookupFunc               ,
    genClosure_VfsFileLookupFunc            ,
    mk_VfsFileLookupFunc                    ,
    noVfsFileLookupFunc                     ,
    noVfsFileLookupFunc_WithClosures        ,
    wrap_VfsFileLookupFunc                  ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Enums as GLib.Enums
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.DateTime as GLib.DateTime
import qualified GI.GLib.Structs.KeyFile as GLib.KeyFile
import qualified GI.GLib.Structs.MainContext as GLib.MainContext
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GLib.Structs.TimeVal as GLib.TimeVal
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.Parameter as GObject.Parameter
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Action as Gio.Action
import {-# SOURCE #-} qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AppInfo as Gio.AppInfo
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DBusInterface as Gio.DBusInterface
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DBusObject as Gio.DBusObject
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DBusObjectManager as Gio.DBusObjectManager
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DatagramBased as Gio.DatagramBased
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Drive as Gio.Drive
import {-# SOURCE #-} qualified GI.Gio.Interfaces.File as Gio.File
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Icon as Gio.Icon
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Initable as Gio.Initable
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Mount as Gio.Mount
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
import {-# SOURCE #-} qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Volume as Gio.Volume
import {-# SOURCE #-} qualified GI.Gio.Objects.AppLaunchContext as Gio.AppLaunchContext
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.Credentials as Gio.Credentials
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusAuthObserver as Gio.DBusAuthObserver
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMessage as Gio.DBusMessage
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMethodInvocation as Gio.DBusMethodInvocation
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusObjectManagerClient as Gio.DBusObjectManagerClient
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusObjectProxy as Gio.DBusObjectProxy
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusProxy as Gio.DBusProxy
import {-# SOURCE #-} qualified GI.Gio.Objects.DesktopAppInfo as Gio.DesktopAppInfo
import {-# SOURCE #-} qualified GI.Gio.Objects.FileEnumerator as Gio.FileEnumerator
import {-# SOURCE #-} qualified GI.Gio.Objects.FileIOStream as Gio.FileIOStream
import {-# SOURCE #-} qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
import {-# SOURCE #-} qualified GI.Gio.Objects.FileInputStream as Gio.FileInputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.FileMonitor as Gio.FileMonitor
import {-# SOURCE #-} qualified GI.Gio.Objects.FileOutputStream as Gio.FileOutputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream
import {-# SOURCE #-} qualified GI.Gio.Objects.InetAddress as Gio.InetAddress
import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuAttributeIter as Gio.MenuAttributeIter
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuLinkIter as Gio.MenuLinkIter
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import {-# SOURCE #-} qualified GI.Gio.Objects.MountOperation as Gio.MountOperation
import {-# SOURCE #-} qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.SimpleAction as Gio.SimpleAction
import {-# SOURCE #-} qualified GI.Gio.Objects.SimpleAsyncResult as Gio.SimpleAsyncResult
import {-# SOURCE #-} qualified GI.Gio.Objects.Socket as Gio.Socket
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddressEnumerator as Gio.SocketAddressEnumerator
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketConnection as Gio.SocketConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketControlMessage as Gio.SocketControlMessage
import {-# SOURCE #-} qualified GI.Gio.Objects.Task as Gio.Task
import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList
import {-# SOURCE #-} qualified GI.Gio.Objects.Vfs as Gio.Vfs
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusAnnotationInfo as Gio.DBusAnnotationInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusArgInfo as Gio.DBusArgInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceInfo as Gio.DBusInterfaceInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceVTable as Gio.DBusInterfaceVTable
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusMethodInfo as Gio.DBusMethodInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusPropertyInfo as Gio.DBusPropertyInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusSignalInfo as Gio.DBusSignalInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusSubtreeVTable as Gio.DBusSubtreeVTable
import {-# SOURCE #-} qualified GI.Gio.Structs.FileAttributeInfo as Gio.FileAttributeInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.FileAttributeInfoList as Gio.FileAttributeInfoList
import {-# SOURCE #-} qualified GI.Gio.Structs.FileAttributeMatcher as Gio.FileAttributeMatcher
import {-# SOURCE #-} qualified GI.Gio.Structs.IOSchedulerJob as Gio.IOSchedulerJob
import {-# SOURCE #-} qualified GI.Gio.Structs.InputMessage as Gio.InputMessage
import {-# SOURCE #-} qualified GI.Gio.Structs.InputVector as Gio.InputVector
import {-# SOURCE #-} qualified GI.Gio.Structs.OutputMessage as Gio.OutputMessage
import {-# SOURCE #-} qualified GI.Gio.Structs.OutputVector as Gio.OutputVector

#else
import qualified GI.GLib.Enums as GLib.Enums
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DatagramBased as Gio.DatagramBased
import {-# SOURCE #-} qualified GI.Gio.Interfaces.File as Gio.File
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMessage as Gio.DBusMessage
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMethodInvocation as Gio.DBusMethodInvocation
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusObjectManagerClient as Gio.DBusObjectManagerClient
import {-# SOURCE #-} qualified GI.Gio.Objects.DesktopAppInfo as Gio.DesktopAppInfo
import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.SimpleAction as Gio.SimpleAction
import {-# SOURCE #-} qualified GI.Gio.Objects.SimpleAsyncResult as Gio.SimpleAsyncResult
import {-# SOURCE #-} qualified GI.Gio.Objects.Socket as Gio.Socket
import {-# SOURCE #-} qualified GI.Gio.Objects.Task as Gio.Task
import {-# SOURCE #-} qualified GI.Gio.Objects.Vfs as Gio.Vfs
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceInfo as Gio.DBusInterfaceInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceVTable as Gio.DBusInterfaceVTable
import {-# SOURCE #-} qualified GI.Gio.Structs.IOSchedulerJob as Gio.IOSchedulerJob

#endif

-- callback VfsFileLookupFunc
{- Callable
  { returnType =
      Just (TInterface Name { namespace = "Gio" , name = "File" })
  , returnMayBeNull = False
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation
        { rawDocText = Just "a #GFile for @identifier."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "vfs"
          , argType = TInterface Name { namespace = "Gio" , name = "Vfs" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GVfs" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "identifier"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "the identifier to look up a #GFile for. This can either\n    be an URI or a parse name as returned by g_file_get_parse_name()"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "user data passed to the function"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "This function type is used by g_vfs_register_uri_scheme() to make it\npossible for a client to associate an URI scheme to a different #GFile\nimplementation.\n\nThe client should return a reference to the new file that has been\ncreated for @uri, or %NULL to continue with the default implementation."
        , sinceVersion = Just "2.50"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_VfsFileLookupFunc =
    Ptr Gio.Vfs.Vfs ->
    CString ->
    Ptr () ->
    IO (Ptr Gio.File.File)

-- Args: [ Arg
--           { argCName = "vfs"
--           , argType = TInterface Name { namespace = "Gio" , name = "Vfs" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GVfs" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "identifier"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the identifier to look up a #GFile for. This can either\n    be an URI or a parse name as returned by g_file_get_parse_name()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed to the function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "File" })
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_VfsFileLookupFunc :: FunPtr C_VfsFileLookupFunc -> C_VfsFileLookupFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_VfsFileLookupFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Vfs.IsVfs a) =>
    FunPtr C_VfsFileLookupFunc
    -> a
    -- ^ /@vfs@/: a t'GI.Gio.Objects.Vfs.Vfs'
    -> T.Text
    -- ^ /@identifier@/: the identifier to look up a t'GI.Gio.Interfaces.File.File' for. This can either
    --     be an URI or a parse name as returned by 'GI.Gio.Interfaces.File.fileGetParseName'
    -> Ptr ()
    -- ^ /@userData@/: user data passed to the function
    -> m Gio.File.File
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.File.File' for /@identifier@/.
dynamic_VfsFileLookupFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVfs a) =>
FunPtr C_VfsFileLookupFunc -> a -> Text -> Ptr () -> m File
dynamic_VfsFileLookupFunc FunPtr C_VfsFileLookupFunc
__funPtr a
vfs Text
identifier Ptr ()
userData = IO File -> m File
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO File -> m File) -> IO File -> m File
forall a b. (a -> b) -> a -> b
$ do
    vfs' <- a -> IO (Ptr Vfs)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
vfs
    identifier' <- textToCString identifier
    result <- (__dynamic_C_VfsFileLookupFunc __funPtr) vfs' identifier' userData
    checkUnexpectedReturnNULL "vfsFileLookupFunc" result
    result' <- (wrapObject Gio.File.File) result
    touchManagedPtr vfs
    freeMem identifier'
    return result'

-- | Generate a function pointer callable from C code, from a `C_VfsFileLookupFunc`.
foreign import ccall "wrapper"
    mk_VfsFileLookupFunc :: C_VfsFileLookupFunc -> IO (FunPtr C_VfsFileLookupFunc)

-- | This function type is used by 'GI.Gio.Objects.Vfs.vfsRegisterUriScheme' to make it
-- possible for a client to associate an URI scheme to a different t'GI.Gio.Interfaces.File.File'
-- implementation.
-- 
-- The client should return a reference to the new file that has been
-- created for /@uri@/, or 'P.Nothing' to continue with the default implementation.
-- 
-- /Since: 2.50/
type VfsFileLookupFunc =
    Gio.Vfs.Vfs
    -- ^ /@vfs@/: a t'GI.Gio.Objects.Vfs.Vfs'
    -> T.Text
    -- ^ /@identifier@/: the identifier to look up a t'GI.Gio.Interfaces.File.File' for. This can either
    --     be an URI or a parse name as returned by 'GI.Gio.Interfaces.File.fileGetParseName'
    -> IO Gio.File.File
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.File.File' for /@identifier@/.

-- | A convenience synonym for @`Nothing` :: `Maybe` `VfsFileLookupFunc`@.
noVfsFileLookupFunc :: Maybe VfsFileLookupFunc
noVfsFileLookupFunc :: Maybe VfsFileLookupFunc
noVfsFileLookupFunc = Maybe VfsFileLookupFunc
forall a. Maybe a
Nothing

-- | This function type is used by 'GI.Gio.Objects.Vfs.vfsRegisterUriScheme' to make it
-- possible for a client to associate an URI scheme to a different t'GI.Gio.Interfaces.File.File'
-- implementation.
-- 
-- The client should return a reference to the new file that has been
-- created for /@uri@/, or 'P.Nothing' to continue with the default implementation.
-- 
-- /Since: 2.50/
type VfsFileLookupFunc_WithClosures =
    Gio.Vfs.Vfs
    -- ^ /@vfs@/: a t'GI.Gio.Objects.Vfs.Vfs'
    -> T.Text
    -- ^ /@identifier@/: the identifier to look up a t'GI.Gio.Interfaces.File.File' for. This can either
    --     be an URI or a parse name as returned by 'GI.Gio.Interfaces.File.fileGetParseName'
    -> Ptr ()
    -- ^ /@userData@/: user data passed to the function
    -> IO Gio.File.File
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.File.File' for /@identifier@/.

-- | A convenience synonym for @`Nothing` :: `Maybe` `VfsFileLookupFunc_WithClosures`@.
noVfsFileLookupFunc_WithClosures :: Maybe VfsFileLookupFunc_WithClosures
noVfsFileLookupFunc_WithClosures :: Maybe VfsFileLookupFunc_WithClosures
noVfsFileLookupFunc_WithClosures = Maybe VfsFileLookupFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_VfsFileLookupFunc :: VfsFileLookupFunc -> VfsFileLookupFunc_WithClosures
drop_closures_VfsFileLookupFunc :: VfsFileLookupFunc -> VfsFileLookupFunc_WithClosures
drop_closures_VfsFileLookupFunc VfsFileLookupFunc
_f Vfs
vfs Text
identifier Ptr ()
_ = VfsFileLookupFunc
_f Vfs
vfs Text
identifier

-- | Wrap the callback into a `GClosure`.
genClosure_VfsFileLookupFunc :: MonadIO m => VfsFileLookupFunc -> m (GClosure C_VfsFileLookupFunc)
genClosure_VfsFileLookupFunc :: forall (m :: * -> *).
MonadIO m =>
VfsFileLookupFunc -> m (GClosure C_VfsFileLookupFunc)
genClosure_VfsFileLookupFunc VfsFileLookupFunc
cb = IO (GClosure C_VfsFileLookupFunc)
-> m (GClosure C_VfsFileLookupFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VfsFileLookupFunc)
 -> m (GClosure C_VfsFileLookupFunc))
-> IO (GClosure C_VfsFileLookupFunc)
-> m (GClosure C_VfsFileLookupFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: VfsFileLookupFunc_WithClosures
cb' = VfsFileLookupFunc -> VfsFileLookupFunc_WithClosures
drop_closures_VfsFileLookupFunc VfsFileLookupFunc
cb
    let cb'' :: C_VfsFileLookupFunc
cb'' = Maybe (Ptr (FunPtr C_VfsFileLookupFunc))
-> VfsFileLookupFunc_WithClosures -> C_VfsFileLookupFunc
wrap_VfsFileLookupFunc Maybe (Ptr (FunPtr C_VfsFileLookupFunc))
forall a. Maybe a
Nothing VfsFileLookupFunc_WithClosures
cb'
    C_VfsFileLookupFunc -> IO (FunPtr C_VfsFileLookupFunc)
mk_VfsFileLookupFunc C_VfsFileLookupFunc
cb'' IO (FunPtr C_VfsFileLookupFunc)
-> (FunPtr C_VfsFileLookupFunc
    -> IO (GClosure C_VfsFileLookupFunc))
-> IO (GClosure C_VfsFileLookupFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VfsFileLookupFunc -> IO (GClosure C_VfsFileLookupFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VfsFileLookupFunc` into a `C_VfsFileLookupFunc`.
wrap_VfsFileLookupFunc :: 
    Maybe (Ptr (FunPtr C_VfsFileLookupFunc)) ->
    VfsFileLookupFunc_WithClosures ->
    C_VfsFileLookupFunc
wrap_VfsFileLookupFunc :: Maybe (Ptr (FunPtr C_VfsFileLookupFunc))
-> VfsFileLookupFunc_WithClosures -> C_VfsFileLookupFunc
wrap_VfsFileLookupFunc Maybe (Ptr (FunPtr C_VfsFileLookupFunc))
gi'funptrptr VfsFileLookupFunc_WithClosures
gi'cb Ptr Vfs
vfs CString
identifier Ptr ()
userData = do
    vfs' <- ((ManagedPtr Vfs -> Vfs) -> Ptr Vfs -> IO Vfs
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Vfs -> Vfs
Gio.Vfs.Vfs) Ptr Vfs
vfs
    identifier' <- cstringToText identifier
    result <- gi'cb  vfs' identifier' userData
    maybeReleaseFunPtr gi'funptrptr
    result' <- B.ManagedPtr.disownObject result
    return result'


-- callback TaskThreadFunc
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "task"
          , argType = TInterface Name { namespace = "Gio" , name = "Task" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the #GTask" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "source_object"
          , argType =
              TInterface Name { namespace = "GObject" , name = "Object" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "@task's source object"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "task_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "@task's task data" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "@task's #GCancellable, or %NULL"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The prototype for a task function to be run in a thread via\ng_task_run_in_thread() or g_task_run_in_thread_sync().\n\nIf the return-on-cancel flag is set on @task, and @cancellable gets\ncancelled, then the #GTask will be completed immediately (as though\ng_task_return_error_if_cancelled() had been called), without\nwaiting for the task function to complete. However, the task\nfunction will continue running in its thread in the background. The\nfunction therefore needs to be careful about how it uses\nexternally-visible state in this case. See\ng_task_set_return_on_cancel() for more details.\n\nOther than in that case, @task will be completed when the\n#GTaskThreadFunc returns, not when it calls a\n`g_task_return_` function."
        , sinceVersion = Just "2.36"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_TaskThreadFunc =
    Ptr Gio.Task.Task ->
    Ptr GObject.Object.Object ->
    Ptr () ->
    Ptr Gio.Cancellable.Cancellable ->
    IO ()

-- Args: [ Arg
--           { argCName = "task"
--           , argType = TInterface Name { namespace = "Gio" , name = "Task" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GTask" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source_object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "@task's source object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "task_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "@task's task data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "@task's #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TaskThreadFunc :: FunPtr C_TaskThreadFunc -> C_TaskThreadFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TaskThreadFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Task.IsTask a, GObject.Object.IsObject b, Gio.Cancellable.IsCancellable c) =>
    FunPtr C_TaskThreadFunc
    -> a
    -- ^ /@task@/: the t'GI.Gio.Objects.Task.Task'
    -> b
    -- ^ /@sourceObject@/: /@task@/\'s source object
    -> Ptr ()
    -- ^ /@taskData@/: /@task@/\'s task data
    -> Maybe (c)
    -- ^ /@cancellable@/: /@task@/\'s t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m ()
dynamic_TaskThreadFunc :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsTask a, IsObject b, IsCancellable c) =>
FunPtr C_TaskThreadFunc -> a -> b -> Ptr () -> Maybe c -> m ()
dynamic_TaskThreadFunc FunPtr C_TaskThreadFunc
__funPtr a
task b
sourceObject Ptr ()
taskData Maybe c
cancellable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
    sourceObject' <- unsafeManagedPtrCastPtr sourceObject
    maybeCancellable <- case cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just c
jCancellable -> do
            jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            return jCancellable'
    (__dynamic_C_TaskThreadFunc __funPtr) task' sourceObject' taskData maybeCancellable
    touchManagedPtr task
    touchManagedPtr sourceObject
    whenJust cancellable touchManagedPtr
    return ()

-- | Generate a function pointer callable from C code, from a `C_TaskThreadFunc`.
foreign import ccall "wrapper"
    mk_TaskThreadFunc :: C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)

-- | The prototype for a task function to be run in a thread via
-- 'GI.Gio.Objects.Task.taskRunInThread' or 'GI.Gio.Objects.Task.taskRunInThreadSync'.
-- 
-- If the return-on-cancel flag is set on /@task@/, and /@cancellable@/ gets
-- cancelled, then the t'GI.Gio.Objects.Task.Task' will be completed immediately (as though
-- 'GI.Gio.Objects.Task.taskReturnErrorIfCancelled' had been called), without
-- waiting for the task function to complete. However, the task
-- function will continue running in its thread in the background. The
-- function therefore needs to be careful about how it uses
-- externally-visible state in this case. See
-- 'GI.Gio.Objects.Task.taskSetReturnOnCancel' for more details.
-- 
-- Other than in that case, /@task@/ will be completed when the
-- t'GI.Gio.Callbacks.TaskThreadFunc' returns, not when it calls a
-- @g_task_return_@ function.
-- 
-- /Since: 2.36/
type TaskThreadFunc =
    Gio.Task.Task
    -- ^ /@task@/: the t'GI.Gio.Objects.Task.Task'
    -> GObject.Object.Object
    -- ^ /@sourceObject@/: /@task@/\'s source object
    -> Ptr ()
    -- ^ /@taskData@/: /@task@/\'s task data
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: /@task@/\'s t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TaskThreadFunc`@.
noTaskThreadFunc :: Maybe TaskThreadFunc
noTaskThreadFunc :: Maybe TaskThreadFunc
noTaskThreadFunc = Maybe TaskThreadFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TaskThreadFunc :: MonadIO m => TaskThreadFunc -> m (GClosure C_TaskThreadFunc)
genClosure_TaskThreadFunc :: forall (m :: * -> *).
MonadIO m =>
TaskThreadFunc -> m (GClosure C_TaskThreadFunc)
genClosure_TaskThreadFunc TaskThreadFunc
cb = IO (GClosure C_TaskThreadFunc) -> m (GClosure C_TaskThreadFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TaskThreadFunc) -> m (GClosure C_TaskThreadFunc))
-> IO (GClosure C_TaskThreadFunc) -> m (GClosure C_TaskThreadFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TaskThreadFunc
cb' = Maybe (Ptr (FunPtr C_TaskThreadFunc))
-> TaskThreadFunc -> C_TaskThreadFunc
wrap_TaskThreadFunc Maybe (Ptr (FunPtr C_TaskThreadFunc))
forall a. Maybe a
Nothing TaskThreadFunc
cb
    C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)
mk_TaskThreadFunc C_TaskThreadFunc
cb' IO (FunPtr C_TaskThreadFunc)
-> (FunPtr C_TaskThreadFunc -> IO (GClosure C_TaskThreadFunc))
-> IO (GClosure C_TaskThreadFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TaskThreadFunc -> IO (GClosure C_TaskThreadFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `TaskThreadFunc` into a `C_TaskThreadFunc`.
wrap_TaskThreadFunc :: 
    Maybe (Ptr (FunPtr C_TaskThreadFunc)) ->
    TaskThreadFunc ->
    C_TaskThreadFunc
wrap_TaskThreadFunc :: Maybe (Ptr (FunPtr C_TaskThreadFunc))
-> TaskThreadFunc -> C_TaskThreadFunc
wrap_TaskThreadFunc Maybe (Ptr (FunPtr C_TaskThreadFunc))
gi'funptrptr TaskThreadFunc
gi'cb Ptr Task
task Ptr Object
sourceObject Ptr ()
taskData Ptr Cancellable
cancellable = do
    task' <- ((ManagedPtr Task -> Task) -> Ptr Task -> IO Task
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Task -> Task
Gio.Task.Task) Ptr Task
task
    sourceObject' <- (newObject GObject.Object.Object) sourceObject
    maybeCancellable <-
        if cancellable == FP.nullPtr
        then return Nothing
        else do
            cancellable' <- (newObject Gio.Cancellable.Cancellable) cancellable
            return $ Just cancellable'
    gi'cb  task' sourceObject' taskData maybeCancellable
    maybeReleaseFunPtr gi'funptrptr


-- callback SocketSourceFunc
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just "it should return %FALSE if the source should be removed."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "socket"
          , argType = TInterface Name { namespace = "Gio" , name = "Socket" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the #GSocket" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "condition"
          , argType =
              TInterface Name { namespace = "GLib" , name = "IOCondition" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the current condition at the source fired."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "data passed in by the user."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "This is the function type of the callback used for the #GSource\nreturned by g_socket_create_source()."
        , sinceVersion = Just "2.22"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SocketSourceFunc =
    Ptr Gio.Socket.Socket ->
    CUInt ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "socket"
--           , argType = TInterface Name { namespace = "Gio" , name = "Socket" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSocket" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "condition"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "IOCondition" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the current condition at the source fired."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data passed in by the user."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SocketSourceFunc :: FunPtr C_SocketSourceFunc -> C_SocketSourceFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SocketSourceFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Socket.IsSocket a) =>
    FunPtr C_SocketSourceFunc
    -> a
    -- ^ /@socket@/: the t'GI.Gio.Objects.Socket.Socket'
    -> [GLib.Flags.IOCondition]
    -- ^ /@condition@/: the current condition at the source fired.
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> m Bool
    -- ^ __Returns:__ it should return 'P.False' if the source should be removed.
dynamic_SocketSourceFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSocket a) =>
FunPtr C_SocketSourceFunc -> a -> [IOCondition] -> Ptr () -> m Bool
dynamic_SocketSourceFunc FunPtr C_SocketSourceFunc
__funPtr a
socket [IOCondition]
condition Ptr ()
data_ = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    socket' <- a -> IO (Ptr Socket)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
socket
    let condition' = [IOCondition] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [IOCondition]
condition
    result <- (__dynamic_C_SocketSourceFunc __funPtr) socket' condition' data_
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr socket
    return result'

-- | Generate a function pointer callable from C code, from a `C_SocketSourceFunc`.
foreign import ccall "wrapper"
    mk_SocketSourceFunc :: C_SocketSourceFunc -> IO (FunPtr C_SocketSourceFunc)

-- | This is the function type of the callback used for the t'GI.GLib.Structs.Source.Source'
-- returned by @/g_socket_create_source()/@.
-- 
-- /Since: 2.22/
type SocketSourceFunc =
    Gio.Socket.Socket
    -- ^ /@socket@/: the t'GI.Gio.Objects.Socket.Socket'
    -> [GLib.Flags.IOCondition]
    -- ^ /@condition@/: the current condition at the source fired.
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> IO Bool
    -- ^ __Returns:__ it should return 'P.False' if the source should be removed.

-- | A convenience synonym for @`Nothing` :: `Maybe` `SocketSourceFunc`@.
noSocketSourceFunc :: Maybe SocketSourceFunc
noSocketSourceFunc :: Maybe SocketSourceFunc
noSocketSourceFunc = Maybe SocketSourceFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_SocketSourceFunc :: MonadIO m => SocketSourceFunc -> m (GClosure C_SocketSourceFunc)
genClosure_SocketSourceFunc :: forall (m :: * -> *).
MonadIO m =>
SocketSourceFunc -> m (GClosure C_SocketSourceFunc)
genClosure_SocketSourceFunc SocketSourceFunc
cb = IO (GClosure C_SocketSourceFunc) -> m (GClosure C_SocketSourceFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SocketSourceFunc)
 -> m (GClosure C_SocketSourceFunc))
-> IO (GClosure C_SocketSourceFunc)
-> m (GClosure C_SocketSourceFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SocketSourceFunc
cb' = Maybe (Ptr (FunPtr C_SocketSourceFunc))
-> SocketSourceFunc -> C_SocketSourceFunc
wrap_SocketSourceFunc Maybe (Ptr (FunPtr C_SocketSourceFunc))
forall a. Maybe a
Nothing SocketSourceFunc
cb
    C_SocketSourceFunc -> IO (FunPtr C_SocketSourceFunc)
mk_SocketSourceFunc C_SocketSourceFunc
cb' IO (FunPtr C_SocketSourceFunc)
-> (FunPtr C_SocketSourceFunc -> IO (GClosure C_SocketSourceFunc))
-> IO (GClosure C_SocketSourceFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SocketSourceFunc -> IO (GClosure C_SocketSourceFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SocketSourceFunc` into a `C_SocketSourceFunc`.
wrap_SocketSourceFunc :: 
    Maybe (Ptr (FunPtr C_SocketSourceFunc)) ->
    SocketSourceFunc ->
    C_SocketSourceFunc
wrap_SocketSourceFunc :: Maybe (Ptr (FunPtr C_SocketSourceFunc))
-> SocketSourceFunc -> C_SocketSourceFunc
wrap_SocketSourceFunc Maybe (Ptr (FunPtr C_SocketSourceFunc))
gi'funptrptr SocketSourceFunc
gi'cb Ptr Socket
socket CUInt
condition Ptr ()
data_ = do
    socket' <- ((ManagedPtr Socket -> Socket) -> Ptr Socket -> IO Socket
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Socket -> Socket
Gio.Socket.Socket) Ptr Socket
socket
    let condition' = CUInt -> [IOCondition]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
condition
    result <- gi'cb  socket' condition' data_
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback SimpleAsyncThreadFunc
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "res"
          , argType =
              TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GSimpleAsyncResult."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object"
          , argType =
              TInterface Name { namespace = "GObject" , name = "Object" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GObject." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "optional #GCancellable object, %NULL to ignore."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Simple thread function that runs an asynchronous operation and\nchecks for cancellation."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SimpleAsyncThreadFunc =
    Ptr Gio.SimpleAsyncResult.SimpleAsyncResult ->
    Ptr GObject.Object.Object ->
    Ptr Gio.Cancellable.Cancellable ->
    IO ()

-- Args: [ Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "SimpleAsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSimpleAsyncResult."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional #GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SimpleAsyncThreadFunc :: FunPtr C_SimpleAsyncThreadFunc -> C_SimpleAsyncThreadFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SimpleAsyncThreadFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.SimpleAsyncResult.IsSimpleAsyncResult a, GObject.Object.IsObject b, Gio.Cancellable.IsCancellable c) =>
    FunPtr C_SimpleAsyncThreadFunc
    -> a
    -- ^ /@res@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
    -> b
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'.
    -> Maybe (c)
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> m ()
dynamic_SimpleAsyncThreadFunc :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsSimpleAsyncResult a, IsObject b,
 IsCancellable c) =>
FunPtr C_SimpleAsyncThreadFunc -> a -> b -> Maybe c -> m ()
dynamic_SimpleAsyncThreadFunc FunPtr C_SimpleAsyncThreadFunc
__funPtr a
res b
object Maybe c
cancellable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    res' <- a -> IO (Ptr SimpleAsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    object' <- unsafeManagedPtrCastPtr object
    maybeCancellable <- case cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just c
jCancellable -> do
            jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            return jCancellable'
    (__dynamic_C_SimpleAsyncThreadFunc __funPtr) res' object' maybeCancellable
    touchManagedPtr res
    touchManagedPtr object
    whenJust cancellable touchManagedPtr
    return ()

-- | Generate a function pointer callable from C code, from a `C_SimpleAsyncThreadFunc`.
foreign import ccall "wrapper"
    mk_SimpleAsyncThreadFunc :: C_SimpleAsyncThreadFunc -> IO (FunPtr C_SimpleAsyncThreadFunc)

-- | Simple thread function that runs an asynchronous operation and
-- checks for cancellation.
type SimpleAsyncThreadFunc =
    Gio.SimpleAsyncResult.SimpleAsyncResult
    -- ^ /@res@/: a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.
    -> GObject.Object.Object
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'.
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleAsyncThreadFunc`@.
noSimpleAsyncThreadFunc :: Maybe SimpleAsyncThreadFunc
noSimpleAsyncThreadFunc :: Maybe SimpleAsyncThreadFunc
noSimpleAsyncThreadFunc = Maybe SimpleAsyncThreadFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_SimpleAsyncThreadFunc :: MonadIO m => SimpleAsyncThreadFunc -> m (GClosure C_SimpleAsyncThreadFunc)
genClosure_SimpleAsyncThreadFunc :: forall (m :: * -> *).
MonadIO m =>
SimpleAsyncThreadFunc -> m (GClosure C_SimpleAsyncThreadFunc)
genClosure_SimpleAsyncThreadFunc SimpleAsyncThreadFunc
cb = IO (GClosure C_SimpleAsyncThreadFunc)
-> m (GClosure C_SimpleAsyncThreadFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SimpleAsyncThreadFunc)
 -> m (GClosure C_SimpleAsyncThreadFunc))
-> IO (GClosure C_SimpleAsyncThreadFunc)
-> m (GClosure C_SimpleAsyncThreadFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SimpleAsyncThreadFunc
cb' = Maybe (Ptr (FunPtr C_SimpleAsyncThreadFunc))
-> SimpleAsyncThreadFunc -> C_SimpleAsyncThreadFunc
wrap_SimpleAsyncThreadFunc Maybe (Ptr (FunPtr C_SimpleAsyncThreadFunc))
forall a. Maybe a
Nothing SimpleAsyncThreadFunc
cb
    C_SimpleAsyncThreadFunc -> IO (FunPtr C_SimpleAsyncThreadFunc)
mk_SimpleAsyncThreadFunc C_SimpleAsyncThreadFunc
cb' IO (FunPtr C_SimpleAsyncThreadFunc)
-> (FunPtr C_SimpleAsyncThreadFunc
    -> IO (GClosure C_SimpleAsyncThreadFunc))
-> IO (GClosure C_SimpleAsyncThreadFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SimpleAsyncThreadFunc
-> IO (GClosure C_SimpleAsyncThreadFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SimpleAsyncThreadFunc` into a `C_SimpleAsyncThreadFunc`.
wrap_SimpleAsyncThreadFunc :: 
    Maybe (Ptr (FunPtr C_SimpleAsyncThreadFunc)) ->
    SimpleAsyncThreadFunc ->
    C_SimpleAsyncThreadFunc
wrap_SimpleAsyncThreadFunc :: Maybe (Ptr (FunPtr C_SimpleAsyncThreadFunc))
-> SimpleAsyncThreadFunc -> C_SimpleAsyncThreadFunc
wrap_SimpleAsyncThreadFunc Maybe (Ptr (FunPtr C_SimpleAsyncThreadFunc))
gi'funptrptr SimpleAsyncThreadFunc
gi'cb Ptr SimpleAsyncResult
res Ptr Object
object Ptr Cancellable
cancellable = do
    res' <- ((ManagedPtr SimpleAsyncResult -> SimpleAsyncResult)
-> Ptr SimpleAsyncResult -> IO SimpleAsyncResult
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SimpleAsyncResult -> SimpleAsyncResult
Gio.SimpleAsyncResult.SimpleAsyncResult) Ptr SimpleAsyncResult
res
    object' <- (newObject GObject.Object.Object) object
    maybeCancellable <-
        if cancellable == FP.nullPtr
        then return Nothing
        else do
            cancellable' <- (newObject Gio.Cancellable.Cancellable) cancellable
            return $ Just cancellable'
    gi'cb  res' object' maybeCancellable
    maybeReleaseFunPtr gi'funptrptr


-- callback SettingsGetMapping
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "%TRUE if the conversion succeeded, %FALSE in case of an error"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "value"
          , argType = TVariant
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the #GVariant to map, or %NULL"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "result"
          , argType = TBasicType TPtr
          , direction = DirectionOut
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "the result of the mapping"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferEverything
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the user data that was passed to\ng_settings_get_mapped()"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of the function that is used to convert from a value stored\nin a #GSettings to a value that is useful to the application.\n\nIf the value is successfully mapped, the result should be stored at\n@result and %TRUE returned.  If mapping fails (for example, if @value\nis not in the right format) then %FALSE should be returned.\n\nIf @value is %NULL then it means that the mapping function is being\ngiven a \"last chance\" to successfully return a valid value.  %TRUE\nmust be returned in this case."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SettingsGetMapping =
    Ptr GVariant ->
    Ptr (Ptr ()) ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GVariant to map, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType = TBasicType TPtr
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the result of the mapping"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the user data that was passed to\ng_settings_get_mapped()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SettingsGetMapping :: FunPtr C_SettingsGetMapping -> C_SettingsGetMapping

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SettingsGetMapping ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_SettingsGetMapping
    -> GVariant
    -- ^ /@value@/: the t'GVariant' to map, or 'P.Nothing'
    -> Ptr ()
    -- ^ /@userData@/: the user data that was passed to
    -- 'GI.Gio.Objects.Settings.settingsGetMapped'
    -> m ((Bool, Ptr ()))
    -- ^ __Returns:__ 'P.True' if the conversion succeeded, 'P.False' in case of an error
dynamic_SettingsGetMapping :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_SettingsGetMapping
-> GVariant -> Ptr () -> m (Bool, Ptr ())
dynamic_SettingsGetMapping FunPtr C_SettingsGetMapping
__funPtr GVariant
value Ptr ()
userData = IO (Bool, Ptr ()) -> m (Bool, Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Ptr ()) -> m (Bool, Ptr ()))
-> IO (Bool, Ptr ()) -> m (Bool, Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
    result_ <- callocMem :: IO (Ptr (Ptr ()))
    result <- (__dynamic_C_SettingsGetMapping __funPtr) value' result_ userData
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    result_' <- peek result_
    touchManagedPtr value
    freeMem result_
    return (result', result_')

-- | Generate a function pointer callable from C code, from a `C_SettingsGetMapping`.
foreign import ccall "wrapper"
    mk_SettingsGetMapping :: C_SettingsGetMapping -> IO (FunPtr C_SettingsGetMapping)

-- | The type of the function that is used to convert from a value stored
-- in a t'GI.Gio.Objects.Settings.Settings' to a value that is useful to the application.
-- 
-- If the value is successfully mapped, the result should be stored at
-- /@result@/ and 'P.True' returned.  If mapping fails (for example, if /@value@/
-- is not in the right format) then 'P.False' should be returned.
-- 
-- If /@value@/ is 'P.Nothing' then it means that the mapping function is being
-- given a \"last chance\" to successfully return a valid value.  'P.True'
-- must be returned in this case.
type SettingsGetMapping =
    GVariant
    -- ^ /@value@/: the t'GVariant' to map, or 'P.Nothing'
    -> IO ((Bool, Ptr ()))
    -- ^ __Returns:__ 'P.True' if the conversion succeeded, 'P.False' in case of an error

-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsGetMapping`@.
noSettingsGetMapping :: Maybe SettingsGetMapping
noSettingsGetMapping :: Maybe SettingsGetMapping
noSettingsGetMapping = Maybe SettingsGetMapping
forall a. Maybe a
Nothing

-- | The type of the function that is used to convert from a value stored
-- in a t'GI.Gio.Objects.Settings.Settings' to a value that is useful to the application.
-- 
-- If the value is successfully mapped, the result should be stored at
-- /@result@/ and 'P.True' returned.  If mapping fails (for example, if /@value@/
-- is not in the right format) then 'P.False' should be returned.
-- 
-- If /@value@/ is 'P.Nothing' then it means that the mapping function is being
-- given a \"last chance\" to successfully return a valid value.  'P.True'
-- must be returned in this case.
type SettingsGetMapping_WithClosures =
    GVariant
    -- ^ /@value@/: the t'GVariant' to map, or 'P.Nothing'
    -> Ptr ()
    -- ^ /@userData@/: the user data that was passed to
    -- 'GI.Gio.Objects.Settings.settingsGetMapped'
    -> IO ((Bool, Ptr ()))
    -- ^ __Returns:__ 'P.True' if the conversion succeeded, 'P.False' in case of an error

-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsGetMapping_WithClosures`@.
noSettingsGetMapping_WithClosures :: Maybe SettingsGetMapping_WithClosures
noSettingsGetMapping_WithClosures :: Maybe SettingsGetMapping_WithClosures
noSettingsGetMapping_WithClosures = Maybe SettingsGetMapping_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SettingsGetMapping :: SettingsGetMapping -> SettingsGetMapping_WithClosures
drop_closures_SettingsGetMapping :: SettingsGetMapping -> SettingsGetMapping_WithClosures
drop_closures_SettingsGetMapping SettingsGetMapping
_f GVariant
value Ptr ()
_ = SettingsGetMapping
_f GVariant
value

-- | Wrap the callback into a `GClosure`.
genClosure_SettingsGetMapping :: MonadIO m => SettingsGetMapping -> m (GClosure C_SettingsGetMapping)
genClosure_SettingsGetMapping :: forall (m :: * -> *).
MonadIO m =>
SettingsGetMapping -> m (GClosure C_SettingsGetMapping)
genClosure_SettingsGetMapping SettingsGetMapping
cb = IO (GClosure C_SettingsGetMapping)
-> m (GClosure C_SettingsGetMapping)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SettingsGetMapping)
 -> m (GClosure C_SettingsGetMapping))
-> IO (GClosure C_SettingsGetMapping)
-> m (GClosure C_SettingsGetMapping)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: SettingsGetMapping_WithClosures
cb' = SettingsGetMapping -> SettingsGetMapping_WithClosures
drop_closures_SettingsGetMapping SettingsGetMapping
cb
    let cb'' :: C_SettingsGetMapping
cb'' = Maybe (Ptr (FunPtr C_SettingsGetMapping))
-> SettingsGetMapping_WithClosures -> C_SettingsGetMapping
wrap_SettingsGetMapping Maybe (Ptr (FunPtr C_SettingsGetMapping))
forall a. Maybe a
Nothing SettingsGetMapping_WithClosures
cb'
    C_SettingsGetMapping -> IO (FunPtr C_SettingsGetMapping)
mk_SettingsGetMapping C_SettingsGetMapping
cb'' IO (FunPtr C_SettingsGetMapping)
-> (FunPtr C_SettingsGetMapping
    -> IO (GClosure C_SettingsGetMapping))
-> IO (GClosure C_SettingsGetMapping)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SettingsGetMapping -> IO (GClosure C_SettingsGetMapping)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SettingsGetMapping` into a `C_SettingsGetMapping`.
wrap_SettingsGetMapping :: 
    Maybe (Ptr (FunPtr C_SettingsGetMapping)) ->
    SettingsGetMapping_WithClosures ->
    C_SettingsGetMapping
wrap_SettingsGetMapping :: Maybe (Ptr (FunPtr C_SettingsGetMapping))
-> SettingsGetMapping_WithClosures -> C_SettingsGetMapping
wrap_SettingsGetMapping Maybe (Ptr (FunPtr C_SettingsGetMapping))
gi'funptrptr SettingsGetMapping_WithClosures
gi'cb Ptr GVariant
value Ptr (Ptr ())
result_ Ptr ()
userData = do
    value' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
value
    (result, outresult_) <- gi'cb  value' userData
    poke result_ outresult_
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback SettingsBindSetMapping
{- Callable
  { returnType = Just TVariant
  , returnMayBeNull = False
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "a new #GVariant holding the data from @value,\n    or %NULL in case of an error"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "value"
          , argType = TGValue
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "a #GValue containing the property value to map"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "expected_type"
          , argType =
              TInterface Name { namespace = "GLib" , name = "VariantType" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the #GVariantType to create"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "user data that was specified when the binding was created"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type for the function that is used to convert an object property\nvalue to a #GVariant for storing it in #GSettings."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SettingsBindSetMapping =
    Ptr GValue ->
    Ptr GLib.VariantType.VariantType ->
    Ptr () ->
    IO (Ptr GVariant)

-- Args: [ Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GValue containing the property value to map"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expected_type"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "VariantType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GVariantType to create"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "user data that was specified when the binding was created"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SettingsBindSetMapping :: FunPtr C_SettingsBindSetMapping -> C_SettingsBindSetMapping

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SettingsBindSetMapping ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_SettingsBindSetMapping
    -> GValue
    -- ^ /@value@/: a t'GI.GObject.Structs.Value.Value' containing the property value to map
    -> GLib.VariantType.VariantType
    -- ^ /@expectedType@/: the t'GI.GLib.Structs.VariantType.VariantType' to create
    -> Ptr ()
    -- ^ /@userData@/: user data that was specified when the binding was created
    -> m GVariant
    -- ^ __Returns:__ a new t'GVariant' holding the data from /@value@/,
    --     or 'P.Nothing' in case of an error
dynamic_SettingsBindSetMapping :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_SettingsBindSetMapping
-> GValue -> VariantType -> Ptr () -> m GVariant
dynamic_SettingsBindSetMapping FunPtr C_SettingsBindSetMapping
__funPtr GValue
value VariantType
expectedType Ptr ()
userData = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    expectedType' <- unsafeManagedPtrGetPtr expectedType
    result <- (__dynamic_C_SettingsBindSetMapping __funPtr) value' expectedType' userData
    checkUnexpectedReturnNULL "settingsBindSetMapping" result
    result' <- B.GVariant.wrapGVariantPtr result
    touchManagedPtr value
    touchManagedPtr expectedType
    return result'

-- | Generate a function pointer callable from C code, from a `C_SettingsBindSetMapping`.
foreign import ccall "wrapper"
    mk_SettingsBindSetMapping :: C_SettingsBindSetMapping -> IO (FunPtr C_SettingsBindSetMapping)

-- | The type for the function that is used to convert an object property
-- value to a t'GVariant' for storing it in t'GI.Gio.Objects.Settings.Settings'.
type SettingsBindSetMapping =
    GValue
    -- ^ /@value@/: a t'GI.GObject.Structs.Value.Value' containing the property value to map
    -> GLib.VariantType.VariantType
    -- ^ /@expectedType@/: the t'GI.GLib.Structs.VariantType.VariantType' to create
    -> IO GVariant
    -- ^ __Returns:__ a new t'GVariant' holding the data from /@value@/,
    --     or 'P.Nothing' in case of an error

-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsBindSetMapping`@.
noSettingsBindSetMapping :: Maybe SettingsBindSetMapping
noSettingsBindSetMapping :: Maybe SettingsBindSetMapping
noSettingsBindSetMapping = Maybe SettingsBindSetMapping
forall a. Maybe a
Nothing

-- | The type for the function that is used to convert an object property
-- value to a t'GVariant' for storing it in t'GI.Gio.Objects.Settings.Settings'.
type SettingsBindSetMapping_WithClosures =
    GValue
    -- ^ /@value@/: a t'GI.GObject.Structs.Value.Value' containing the property value to map
    -> GLib.VariantType.VariantType
    -- ^ /@expectedType@/: the t'GI.GLib.Structs.VariantType.VariantType' to create
    -> Ptr ()
    -- ^ /@userData@/: user data that was specified when the binding was created
    -> IO GVariant
    -- ^ __Returns:__ a new t'GVariant' holding the data from /@value@/,
    --     or 'P.Nothing' in case of an error

-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsBindSetMapping_WithClosures`@.
noSettingsBindSetMapping_WithClosures :: Maybe SettingsBindSetMapping_WithClosures
noSettingsBindSetMapping_WithClosures :: Maybe SettingsBindSetMapping_WithClosures
noSettingsBindSetMapping_WithClosures = Maybe SettingsBindSetMapping_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SettingsBindSetMapping :: SettingsBindSetMapping -> SettingsBindSetMapping_WithClosures
drop_closures_SettingsBindSetMapping :: SettingsBindSetMapping -> SettingsBindSetMapping_WithClosures
drop_closures_SettingsBindSetMapping SettingsBindSetMapping
_f GValue
value VariantType
expectedType Ptr ()
_ = SettingsBindSetMapping
_f GValue
value VariantType
expectedType

-- | Wrap the callback into a `GClosure`.
genClosure_SettingsBindSetMapping :: MonadIO m => SettingsBindSetMapping -> m (GClosure C_SettingsBindSetMapping)
genClosure_SettingsBindSetMapping :: forall (m :: * -> *).
MonadIO m =>
SettingsBindSetMapping -> m (GClosure C_SettingsBindSetMapping)
genClosure_SettingsBindSetMapping SettingsBindSetMapping
cb = IO (GClosure C_SettingsBindSetMapping)
-> m (GClosure C_SettingsBindSetMapping)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SettingsBindSetMapping)
 -> m (GClosure C_SettingsBindSetMapping))
-> IO (GClosure C_SettingsBindSetMapping)
-> m (GClosure C_SettingsBindSetMapping)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: SettingsBindSetMapping_WithClosures
cb' = SettingsBindSetMapping -> SettingsBindSetMapping_WithClosures
drop_closures_SettingsBindSetMapping SettingsBindSetMapping
cb
    let cb'' :: C_SettingsBindSetMapping
cb'' = Maybe (Ptr (FunPtr C_SettingsBindSetMapping))
-> SettingsBindSetMapping_WithClosures -> C_SettingsBindSetMapping
wrap_SettingsBindSetMapping Maybe (Ptr (FunPtr C_SettingsBindSetMapping))
forall a. Maybe a
Nothing SettingsBindSetMapping_WithClosures
cb'
    C_SettingsBindSetMapping -> IO (FunPtr C_SettingsBindSetMapping)
mk_SettingsBindSetMapping C_SettingsBindSetMapping
cb'' IO (FunPtr C_SettingsBindSetMapping)
-> (FunPtr C_SettingsBindSetMapping
    -> IO (GClosure C_SettingsBindSetMapping))
-> IO (GClosure C_SettingsBindSetMapping)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SettingsBindSetMapping
-> IO (GClosure C_SettingsBindSetMapping)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SettingsBindSetMapping` into a `C_SettingsBindSetMapping`.
wrap_SettingsBindSetMapping :: 
    Maybe (Ptr (FunPtr C_SettingsBindSetMapping)) ->
    SettingsBindSetMapping_WithClosures ->
    C_SettingsBindSetMapping
wrap_SettingsBindSetMapping :: Maybe (Ptr (FunPtr C_SettingsBindSetMapping))
-> SettingsBindSetMapping_WithClosures -> C_SettingsBindSetMapping
wrap_SettingsBindSetMapping Maybe (Ptr (FunPtr C_SettingsBindSetMapping))
gi'funptrptr SettingsBindSetMapping_WithClosures
gi'cb Ptr GValue
value Ptr VariantType
expectedType Ptr ()
userData = do
    value' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
value
    B.ManagedPtr.withTransient  expectedType $ \VariantType
expectedType' -> do
        result <- SettingsBindSetMapping_WithClosures
gi'cb  GValue
value' VariantType
expectedType' Ptr ()
userData
        maybeReleaseFunPtr gi'funptrptr
        result' <- B.GVariant.disownGVariant result
        return result'


-- callback SettingsBindGetMapping
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "%TRUE if the conversion succeeded, %FALSE in case of an error"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "value"
          , argType = TGValue
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "return location for the property value"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "variant"
          , argType = TVariant
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the #GVariant" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "user data that was specified when the binding was created"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type for the function that is used to convert from #GSettings to\nan object property. The @value is already initialized to hold values\nof the appropriate type."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SettingsBindGetMapping =
    Ptr GValue ->
    Ptr GVariant ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the property value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "variant"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GVariant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "user data that was specified when the binding was created"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SettingsBindGetMapping :: FunPtr C_SettingsBindGetMapping -> C_SettingsBindGetMapping

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SettingsBindGetMapping ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_SettingsBindGetMapping
    -> GValue
    -- ^ /@value@/: return location for the property value
    -> GVariant
    -- ^ /@variant@/: the t'GVariant'
    -> Ptr ()
    -- ^ /@userData@/: user data that was specified when the binding was created
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the conversion succeeded, 'P.False' in case of an error
dynamic_SettingsBindGetMapping :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_SettingsBindGetMapping
-> GValue -> GVariant -> Ptr () -> m Bool
dynamic_SettingsBindGetMapping FunPtr C_SettingsBindGetMapping
__funPtr GValue
value GVariant
variant Ptr ()
userData = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    variant' <- unsafeManagedPtrGetPtr variant
    result <- (__dynamic_C_SettingsBindGetMapping __funPtr) value' variant' userData
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr value
    touchManagedPtr variant
    return result'

-- | Generate a function pointer callable from C code, from a `C_SettingsBindGetMapping`.
foreign import ccall "wrapper"
    mk_SettingsBindGetMapping :: C_SettingsBindGetMapping -> IO (FunPtr C_SettingsBindGetMapping)

-- | The type for the function that is used to convert from t'GI.Gio.Objects.Settings.Settings' to
-- an object property. The /@value@/ is already initialized to hold values
-- of the appropriate type.
type SettingsBindGetMapping =
    GValue
    -- ^ /@value@/: return location for the property value
    -> GVariant
    -- ^ /@variant@/: the t'GVariant'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the conversion succeeded, 'P.False' in case of an error

-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsBindGetMapping`@.
noSettingsBindGetMapping :: Maybe SettingsBindGetMapping
noSettingsBindGetMapping :: Maybe SettingsBindGetMapping
noSettingsBindGetMapping = Maybe SettingsBindGetMapping
forall a. Maybe a
Nothing

-- | The type for the function that is used to convert from t'GI.Gio.Objects.Settings.Settings' to
-- an object property. The /@value@/ is already initialized to hold values
-- of the appropriate type.
type SettingsBindGetMapping_WithClosures =
    GValue
    -- ^ /@value@/: return location for the property value
    -> GVariant
    -- ^ /@variant@/: the t'GVariant'
    -> Ptr ()
    -- ^ /@userData@/: user data that was specified when the binding was created
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the conversion succeeded, 'P.False' in case of an error

-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsBindGetMapping_WithClosures`@.
noSettingsBindGetMapping_WithClosures :: Maybe SettingsBindGetMapping_WithClosures
noSettingsBindGetMapping_WithClosures :: Maybe SettingsBindGetMapping_WithClosures
noSettingsBindGetMapping_WithClosures = Maybe SettingsBindGetMapping_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SettingsBindGetMapping :: SettingsBindGetMapping -> SettingsBindGetMapping_WithClosures
drop_closures_SettingsBindGetMapping :: SettingsBindGetMapping -> SettingsBindGetMapping_WithClosures
drop_closures_SettingsBindGetMapping SettingsBindGetMapping
_f GValue
value GVariant
variant Ptr ()
_ = SettingsBindGetMapping
_f GValue
value GVariant
variant

-- | Wrap the callback into a `GClosure`.
genClosure_SettingsBindGetMapping :: MonadIO m => SettingsBindGetMapping -> m (GClosure C_SettingsBindGetMapping)
genClosure_SettingsBindGetMapping :: forall (m :: * -> *).
MonadIO m =>
SettingsBindGetMapping -> m (GClosure C_SettingsBindGetMapping)
genClosure_SettingsBindGetMapping SettingsBindGetMapping
cb = IO (GClosure C_SettingsBindGetMapping)
-> m (GClosure C_SettingsBindGetMapping)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SettingsBindGetMapping)
 -> m (GClosure C_SettingsBindGetMapping))
-> IO (GClosure C_SettingsBindGetMapping)
-> m (GClosure C_SettingsBindGetMapping)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: SettingsBindGetMapping_WithClosures
cb' = SettingsBindGetMapping -> SettingsBindGetMapping_WithClosures
drop_closures_SettingsBindGetMapping SettingsBindGetMapping
cb
    let cb'' :: C_SettingsBindGetMapping
cb'' = Maybe (Ptr (FunPtr C_SettingsBindGetMapping))
-> SettingsBindGetMapping_WithClosures -> C_SettingsBindGetMapping
wrap_SettingsBindGetMapping Maybe (Ptr (FunPtr C_SettingsBindGetMapping))
forall a. Maybe a
Nothing SettingsBindGetMapping_WithClosures
cb'
    C_SettingsBindGetMapping -> IO (FunPtr C_SettingsBindGetMapping)
mk_SettingsBindGetMapping C_SettingsBindGetMapping
cb'' IO (FunPtr C_SettingsBindGetMapping)
-> (FunPtr C_SettingsBindGetMapping
    -> IO (GClosure C_SettingsBindGetMapping))
-> IO (GClosure C_SettingsBindGetMapping)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SettingsBindGetMapping
-> IO (GClosure C_SettingsBindGetMapping)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SettingsBindGetMapping` into a `C_SettingsBindGetMapping`.
wrap_SettingsBindGetMapping :: 
    Maybe (Ptr (FunPtr C_SettingsBindGetMapping)) ->
    SettingsBindGetMapping_WithClosures ->
    C_SettingsBindGetMapping
wrap_SettingsBindGetMapping :: Maybe (Ptr (FunPtr C_SettingsBindGetMapping))
-> SettingsBindGetMapping_WithClosures -> C_SettingsBindGetMapping
wrap_SettingsBindGetMapping Maybe (Ptr (FunPtr C_SettingsBindGetMapping))
gi'funptrptr SettingsBindGetMapping_WithClosures
gi'cb Ptr GValue
value Ptr GVariant
variant Ptr ()
userData = do
    value' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
value
    variant' <- B.GVariant.newGVariantFromPtr variant
    result <- gi'cb  value' variant' userData
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback SeekableIfaceTruncateFnFieldCallback
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "%TRUE if successful. If an error\n    has occurred, this function will return %FALSE and set @error\n    appropriately if present."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "seekable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Seekable" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "offset"
          , argType = TBasicType TInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "new length for @seekable, in bytes."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "optional #GCancellable object, %NULL to ignore."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SeekableIfaceTruncateFnFieldCallback =
    Ptr Gio.Seekable.Seekable ->
    Int64 ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args: [ Arg
--           { argCName = "seekable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Seekable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "offset"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "new length for @seekable, in bytes."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional #GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SeekableIfaceTruncateFnFieldCallback :: FunPtr C_SeekableIfaceTruncateFnFieldCallback -> C_SeekableIfaceTruncateFnFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SeekableIfaceTruncateFnFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Seekable.IsSeekable a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_SeekableIfaceTruncateFnFieldCallback
    -> a
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> Int64
    -- ^ /@offset@/: new length for /@seekable@/, in bytes.
    -> Maybe (b)
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_SeekableIfaceTruncateFnFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
FunPtr C_SeekableIfaceTruncateFnFieldCallback
-> a -> Int64 -> Maybe b -> m ()
dynamic_SeekableIfaceTruncateFnFieldCallback FunPtr C_SeekableIfaceTruncateFnFieldCallback
__funPtr a
seekable Int64
offset Maybe b
cancellable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    seekable' <- a -> IO (Ptr Seekable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ (__dynamic_C_SeekableIfaceTruncateFnFieldCallback __funPtr) seekable' offset maybeCancellable
        touchManagedPtr seekable
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_SeekableIfaceTruncateFnFieldCallback`.
foreign import ccall "wrapper"
    mk_SeekableIfaceTruncateFnFieldCallback :: C_SeekableIfaceTruncateFnFieldCallback -> IO (FunPtr C_SeekableIfaceTruncateFnFieldCallback)

-- | /No description available in the introspection data./
type SeekableIfaceTruncateFnFieldCallback =
    Gio.Seekable.Seekable
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> Int64
    -- ^ /@offset@/: new length for /@seekable@/, in bytes.
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> IO ()
    -- ^ __Returns:__ 'P.True' if successful. If an error
    --     has occurred, this function will return 'P.False' and set /@error@/
    --     appropriately if present. /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `SeekableIfaceTruncateFnFieldCallback`@.
noSeekableIfaceTruncateFnFieldCallback :: Maybe SeekableIfaceTruncateFnFieldCallback
noSeekableIfaceTruncateFnFieldCallback :: Maybe SeekableIfaceTruncateFnFieldCallback
noSeekableIfaceTruncateFnFieldCallback = Maybe SeekableIfaceTruncateFnFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback SeekableIfaceTellFieldCallback
{- Callable
  { returnType = Just (TBasicType TInt64)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "the (positive or zero) offset from the beginning of the\nbuffer, zero if the target is not seekable."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "seekable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Seekable" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SeekableIfaceTellFieldCallback =
    Ptr Gio.Seekable.Seekable ->
    IO Int64

-- Args: [ Arg
--           { argCName = "seekable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Seekable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt64)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SeekableIfaceTellFieldCallback :: FunPtr C_SeekableIfaceTellFieldCallback -> C_SeekableIfaceTellFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SeekableIfaceTellFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Seekable.IsSeekable a) =>
    FunPtr C_SeekableIfaceTellFieldCallback
    -> a
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> m Int64
    -- ^ __Returns:__ the (positive or zero) offset from the beginning of the
    -- buffer, zero if the target is not seekable.
dynamic_SeekableIfaceTellFieldCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
FunPtr C_SeekableIfaceTellFieldCallback -> a -> m Int64
dynamic_SeekableIfaceTellFieldCallback FunPtr C_SeekableIfaceTellFieldCallback
__funPtr a
seekable = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
    seekable' <- a -> IO (Ptr Seekable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
    result <- (__dynamic_C_SeekableIfaceTellFieldCallback __funPtr) seekable'
    touchManagedPtr seekable
    return result

-- | Generate a function pointer callable from C code, from a `C_SeekableIfaceTellFieldCallback`.
foreign import ccall "wrapper"
    mk_SeekableIfaceTellFieldCallback :: C_SeekableIfaceTellFieldCallback -> IO (FunPtr C_SeekableIfaceTellFieldCallback)

-- | /No description available in the introspection data./
type SeekableIfaceTellFieldCallback =
    Gio.Seekable.Seekable
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> IO Int64
    -- ^ __Returns:__ the (positive or zero) offset from the beginning of the
    -- buffer, zero if the target is not seekable.

-- | A convenience synonym for @`Nothing` :: `Maybe` `SeekableIfaceTellFieldCallback`@.
noSeekableIfaceTellFieldCallback :: Maybe SeekableIfaceTellFieldCallback
noSeekableIfaceTellFieldCallback :: Maybe SeekableIfaceTellFieldCallback
noSeekableIfaceTellFieldCallback = Maybe SeekableIfaceTellFieldCallback
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_SeekableIfaceTellFieldCallback :: MonadIO m => SeekableIfaceTellFieldCallback -> m (GClosure C_SeekableIfaceTellFieldCallback)
genClosure_SeekableIfaceTellFieldCallback :: forall (m :: * -> *).
MonadIO m =>
SeekableIfaceTellFieldCallback
-> m (GClosure C_SeekableIfaceTellFieldCallback)
genClosure_SeekableIfaceTellFieldCallback SeekableIfaceTellFieldCallback
cb = IO (GClosure C_SeekableIfaceTellFieldCallback)
-> m (GClosure C_SeekableIfaceTellFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SeekableIfaceTellFieldCallback)
 -> m (GClosure C_SeekableIfaceTellFieldCallback))
-> IO (GClosure C_SeekableIfaceTellFieldCallback)
-> m (GClosure C_SeekableIfaceTellFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SeekableIfaceTellFieldCallback
cb' = Maybe (Ptr (FunPtr C_SeekableIfaceTellFieldCallback))
-> SeekableIfaceTellFieldCallback
-> C_SeekableIfaceTellFieldCallback
wrap_SeekableIfaceTellFieldCallback Maybe (Ptr (FunPtr C_SeekableIfaceTellFieldCallback))
forall a. Maybe a
Nothing SeekableIfaceTellFieldCallback
cb
    C_SeekableIfaceTellFieldCallback
-> IO (FunPtr C_SeekableIfaceTellFieldCallback)
mk_SeekableIfaceTellFieldCallback C_SeekableIfaceTellFieldCallback
cb' IO (FunPtr C_SeekableIfaceTellFieldCallback)
-> (FunPtr C_SeekableIfaceTellFieldCallback
    -> IO (GClosure C_SeekableIfaceTellFieldCallback))
-> IO (GClosure C_SeekableIfaceTellFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SeekableIfaceTellFieldCallback
-> IO (GClosure C_SeekableIfaceTellFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SeekableIfaceTellFieldCallback` into a `C_SeekableIfaceTellFieldCallback`.
wrap_SeekableIfaceTellFieldCallback :: 
    Maybe (Ptr (FunPtr C_SeekableIfaceTellFieldCallback)) ->
    SeekableIfaceTellFieldCallback ->
    C_SeekableIfaceTellFieldCallback
wrap_SeekableIfaceTellFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceTellFieldCallback))
-> SeekableIfaceTellFieldCallback
-> C_SeekableIfaceTellFieldCallback
wrap_SeekableIfaceTellFieldCallback Maybe (Ptr (FunPtr C_SeekableIfaceTellFieldCallback))
gi'funptrptr SeekableIfaceTellFieldCallback
gi'cb Ptr Seekable
seekable = do
    seekable' <- ((ManagedPtr Seekable -> Seekable) -> Ptr Seekable -> IO Seekable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Seekable -> Seekable
Gio.Seekable.Seekable) Ptr Seekable
seekable
    result <- gi'cb  seekable'
    maybeReleaseFunPtr gi'funptrptr
    return result


-- callback SeekableIfaceSeekFieldCallback
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "%TRUE if successful. If an error\n    has occurred, this function will return %FALSE and set @error\n    appropriately if present."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "seekable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Seekable" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "offset"
          , argType = TBasicType TInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #goffset." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "type"
          , argType =
              TInterface Name { namespace = "GLib" , name = "SeekType" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GSeekType." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "optional #GCancellable object, %NULL to ignore."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SeekableIfaceSeekFieldCallback =
    Ptr Gio.Seekable.Seekable ->
    Int64 ->
    CUInt ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args: [ Arg
--           { argCName = "seekable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Seekable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "offset"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #goffset." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "SeekType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSeekType." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional #GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SeekableIfaceSeekFieldCallback :: FunPtr C_SeekableIfaceSeekFieldCallback -> C_SeekableIfaceSeekFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SeekableIfaceSeekFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Seekable.IsSeekable a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_SeekableIfaceSeekFieldCallback
    -> a
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> Int64
    -- ^ /@offset@/: a @/goffset/@.
    -> GLib.Enums.SeekType
    -- ^ /@type@/: a t'GI.GLib.Enums.SeekType'.
    -> Maybe (b)
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_SeekableIfaceSeekFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
FunPtr C_SeekableIfaceSeekFieldCallback
-> a -> Int64 -> SeekType -> Maybe b -> m ()
dynamic_SeekableIfaceSeekFieldCallback FunPtr C_SeekableIfaceSeekFieldCallback
__funPtr a
seekable Int64
offset SeekType
type_ Maybe b
cancellable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    seekable' <- a -> IO (Ptr Seekable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
    let type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SeekType -> Int) -> SeekType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SeekType -> Int
forall a. Enum a => a -> Int
fromEnum) SeekType
type_
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ (__dynamic_C_SeekableIfaceSeekFieldCallback __funPtr) seekable' offset type_' maybeCancellable
        touchManagedPtr seekable
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_SeekableIfaceSeekFieldCallback`.
foreign import ccall "wrapper"
    mk_SeekableIfaceSeekFieldCallback :: C_SeekableIfaceSeekFieldCallback -> IO (FunPtr C_SeekableIfaceSeekFieldCallback)

-- | /No description available in the introspection data./
type SeekableIfaceSeekFieldCallback =
    Gio.Seekable.Seekable
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> Int64
    -- ^ /@offset@/: a @/goffset/@.
    -> GLib.Enums.SeekType
    -- ^ /@type@/: a t'GI.GLib.Enums.SeekType'.
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> IO ()
    -- ^ __Returns:__ 'P.True' if successful. If an error
    --     has occurred, this function will return 'P.False' and set /@error@/
    --     appropriately if present. /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `SeekableIfaceSeekFieldCallback`@.
noSeekableIfaceSeekFieldCallback :: Maybe SeekableIfaceSeekFieldCallback
noSeekableIfaceSeekFieldCallback :: Maybe SeekableIfaceSeekFieldCallback
noSeekableIfaceSeekFieldCallback = Maybe SeekableIfaceSeekFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback SeekableIfaceCanTruncateFieldCallback
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just "%TRUE if the stream can be truncated, %FALSE otherwise."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "seekable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Seekable" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SeekableIfaceCanTruncateFieldCallback =
    Ptr Gio.Seekable.Seekable ->
    IO CInt

-- Args: [ Arg
--           { argCName = "seekable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Seekable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SeekableIfaceCanTruncateFieldCallback :: FunPtr C_SeekableIfaceCanTruncateFieldCallback -> C_SeekableIfaceCanTruncateFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SeekableIfaceCanTruncateFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Seekable.IsSeekable a) =>
    FunPtr C_SeekableIfaceCanTruncateFieldCallback
    -> a
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the stream can be truncated, 'P.False' otherwise.
dynamic_SeekableIfaceCanTruncateFieldCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
FunPtr C_SeekableIfaceCanTruncateFieldCallback -> a -> m Bool
dynamic_SeekableIfaceCanTruncateFieldCallback FunPtr C_SeekableIfaceCanTruncateFieldCallback
__funPtr a
seekable = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    seekable' <- a -> IO (Ptr Seekable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
    result <- (__dynamic_C_SeekableIfaceCanTruncateFieldCallback __funPtr) seekable'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr seekable
    return result'

-- | Generate a function pointer callable from C code, from a `C_SeekableIfaceCanTruncateFieldCallback`.
foreign import ccall "wrapper"
    mk_SeekableIfaceCanTruncateFieldCallback :: C_SeekableIfaceCanTruncateFieldCallback -> IO (FunPtr C_SeekableIfaceCanTruncateFieldCallback)

-- | /No description available in the introspection data./
type SeekableIfaceCanTruncateFieldCallback =
    Gio.Seekable.Seekable
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the stream can be truncated, 'P.False' otherwise.

-- | A convenience synonym for @`Nothing` :: `Maybe` `SeekableIfaceCanTruncateFieldCallback`@.
noSeekableIfaceCanTruncateFieldCallback :: Maybe SeekableIfaceCanTruncateFieldCallback
noSeekableIfaceCanTruncateFieldCallback :: Maybe SeekableIfaceCanTruncateFieldCallback
noSeekableIfaceCanTruncateFieldCallback = Maybe SeekableIfaceCanTruncateFieldCallback
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_SeekableIfaceCanTruncateFieldCallback :: MonadIO m => SeekableIfaceCanTruncateFieldCallback -> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
genClosure_SeekableIfaceCanTruncateFieldCallback :: forall (m :: * -> *).
MonadIO m =>
SeekableIfaceCanTruncateFieldCallback
-> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
genClosure_SeekableIfaceCanTruncateFieldCallback SeekableIfaceCanTruncateFieldCallback
cb = IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
-> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
 -> m (GClosure C_SeekableIfaceCanTruncateFieldCallback))
-> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
-> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SeekableIfaceCanTruncateFieldCallback
cb' = Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
-> SeekableIfaceCanTruncateFieldCallback
-> C_SeekableIfaceCanTruncateFieldCallback
wrap_SeekableIfaceCanTruncateFieldCallback Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
forall a. Maybe a
Nothing SeekableIfaceCanTruncateFieldCallback
cb
    C_SeekableIfaceCanTruncateFieldCallback
-> IO (FunPtr C_SeekableIfaceCanTruncateFieldCallback)
mk_SeekableIfaceCanTruncateFieldCallback C_SeekableIfaceCanTruncateFieldCallback
cb' IO (FunPtr C_SeekableIfaceCanTruncateFieldCallback)
-> (FunPtr C_SeekableIfaceCanTruncateFieldCallback
    -> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback))
-> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SeekableIfaceCanTruncateFieldCallback
-> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SeekableIfaceCanTruncateFieldCallback` into a `C_SeekableIfaceCanTruncateFieldCallback`.
wrap_SeekableIfaceCanTruncateFieldCallback :: 
    Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback)) ->
    SeekableIfaceCanTruncateFieldCallback ->
    C_SeekableIfaceCanTruncateFieldCallback
wrap_SeekableIfaceCanTruncateFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
-> SeekableIfaceCanTruncateFieldCallback
-> C_SeekableIfaceCanTruncateFieldCallback
wrap_SeekableIfaceCanTruncateFieldCallback Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
gi'funptrptr SeekableIfaceCanTruncateFieldCallback
gi'cb Ptr Seekable
seekable = do
    seekable' <- ((ManagedPtr Seekable -> Seekable) -> Ptr Seekable -> IO Seekable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Seekable -> Seekable
Gio.Seekable.Seekable) Ptr Seekable
seekable
    result <- gi'cb  seekable'
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback SeekableIfaceCanSeekFieldCallback
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just "%TRUE if @seekable can be seeked. %FALSE otherwise."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "seekable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Seekable" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_SeekableIfaceCanSeekFieldCallback =
    Ptr Gio.Seekable.Seekable ->
    IO CInt

-- Args: [ Arg
--           { argCName = "seekable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Seekable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSeekable." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SeekableIfaceCanSeekFieldCallback :: FunPtr C_SeekableIfaceCanSeekFieldCallback -> C_SeekableIfaceCanSeekFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SeekableIfaceCanSeekFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Seekable.IsSeekable a) =>
    FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> a
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@seekable@/ can be seeked. 'P.False' otherwise.
dynamic_SeekableIfaceCanSeekFieldCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
FunPtr C_SeekableIfaceCanTruncateFieldCallback -> a -> m Bool
dynamic_SeekableIfaceCanSeekFieldCallback FunPtr C_SeekableIfaceCanTruncateFieldCallback
__funPtr a
seekable = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    seekable' <- a -> IO (Ptr Seekable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
    result <- (__dynamic_C_SeekableIfaceCanSeekFieldCallback __funPtr) seekable'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr seekable
    return result'

-- | Generate a function pointer callable from C code, from a `C_SeekableIfaceCanSeekFieldCallback`.
foreign import ccall "wrapper"
    mk_SeekableIfaceCanSeekFieldCallback :: C_SeekableIfaceCanSeekFieldCallback -> IO (FunPtr C_SeekableIfaceCanSeekFieldCallback)

-- | /No description available in the introspection data./
type SeekableIfaceCanSeekFieldCallback =
    Gio.Seekable.Seekable
    -- ^ /@seekable@/: a t'GI.Gio.Interfaces.Seekable.Seekable'.
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@seekable@/ can be seeked. 'P.False' otherwise.

-- | A convenience synonym for @`Nothing` :: `Maybe` `SeekableIfaceCanSeekFieldCallback`@.
noSeekableIfaceCanSeekFieldCallback :: Maybe SeekableIfaceCanSeekFieldCallback
noSeekableIfaceCanSeekFieldCallback :: Maybe SeekableIfaceCanTruncateFieldCallback
noSeekableIfaceCanSeekFieldCallback = Maybe SeekableIfaceCanTruncateFieldCallback
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_SeekableIfaceCanSeekFieldCallback :: MonadIO m => SeekableIfaceCanSeekFieldCallback -> m (GClosure C_SeekableIfaceCanSeekFieldCallback)
genClosure_SeekableIfaceCanSeekFieldCallback :: forall (m :: * -> *).
MonadIO m =>
SeekableIfaceCanTruncateFieldCallback
-> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
genClosure_SeekableIfaceCanSeekFieldCallback SeekableIfaceCanTruncateFieldCallback
cb = IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
-> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
 -> m (GClosure C_SeekableIfaceCanTruncateFieldCallback))
-> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
-> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SeekableIfaceCanTruncateFieldCallback
cb' = Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
-> SeekableIfaceCanTruncateFieldCallback
-> C_SeekableIfaceCanTruncateFieldCallback
wrap_SeekableIfaceCanSeekFieldCallback Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
forall a. Maybe a
Nothing SeekableIfaceCanTruncateFieldCallback
cb
    C_SeekableIfaceCanTruncateFieldCallback
-> IO (FunPtr C_SeekableIfaceCanTruncateFieldCallback)
mk_SeekableIfaceCanSeekFieldCallback C_SeekableIfaceCanTruncateFieldCallback
cb' IO (FunPtr C_SeekableIfaceCanTruncateFieldCallback)
-> (FunPtr C_SeekableIfaceCanTruncateFieldCallback
    -> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback))
-> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SeekableIfaceCanTruncateFieldCallback
-> IO (GClosure C_SeekableIfaceCanTruncateFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SeekableIfaceCanSeekFieldCallback` into a `C_SeekableIfaceCanSeekFieldCallback`.
wrap_SeekableIfaceCanSeekFieldCallback :: 
    Maybe (Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)) ->
    SeekableIfaceCanSeekFieldCallback ->
    C_SeekableIfaceCanSeekFieldCallback
wrap_SeekableIfaceCanSeekFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
-> SeekableIfaceCanTruncateFieldCallback
-> C_SeekableIfaceCanTruncateFieldCallback
wrap_SeekableIfaceCanSeekFieldCallback Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback))
gi'funptrptr SeekableIfaceCanTruncateFieldCallback
gi'cb Ptr Seekable
seekable = do
    seekable' <- ((ManagedPtr Seekable -> Seekable) -> Ptr Seekable -> IO Seekable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Seekable -> Seekable
Gio.Seekable.Seekable) Ptr Seekable
seekable
    result <- gi'cb  seekable'
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback ReallocFunc
{- Callable
  { returnType = Just (TBasicType TPtr)
  , returnMayBeNull = True
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText = Just "a pointer to the reallocated memory"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "memory block to reallocate"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "size"
          , argType = TBasicType TSize
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "size to reallocate @data to"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Changes the size of the memory block pointed to by @data to\n@size bytes.\n\nThe function should have the same semantics as realloc()."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_ReallocFunc =
    Ptr () ->
    FCT.CSize ->
    IO (Ptr ())

-- Args: [ Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "memory block to reallocate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "size to reallocate @data to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ReallocFunc :: FunPtr C_ReallocFunc -> C_ReallocFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ReallocFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ReallocFunc
    -> Ptr ()
    -- ^ /@data@/: memory block to reallocate
    -> FCT.CSize
    -- ^ /@size@/: size to reallocate /@data@/ to
    -> m (Ptr ())
    -- ^ __Returns:__ a pointer to the reallocated memory
dynamic_ReallocFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_ReallocFunc -> Ptr () -> CSize -> m (Ptr ())
dynamic_ReallocFunc FunPtr C_ReallocFunc
__funPtr Ptr ()
data_ CSize
size = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    result <- (FunPtr C_ReallocFunc -> C_ReallocFunc
__dynamic_C_ReallocFunc FunPtr C_ReallocFunc
__funPtr) Ptr ()
data_ CSize
size
    return result

-- | Generate a function pointer callable from C code, from a `C_ReallocFunc`.
foreign import ccall "wrapper"
    mk_ReallocFunc :: C_ReallocFunc -> IO (FunPtr C_ReallocFunc)

-- | Changes the size of the memory block pointed to by /@data@/ to
-- /@size@/ bytes.
-- 
-- The function should have the same semantics as @/realloc()/@.
type ReallocFunc =
    Ptr ()
    -- ^ /@data@/: memory block to reallocate
    -> FCT.CSize
    -- ^ /@size@/: size to reallocate /@data@/ to
    -> IO (Ptr ())
    -- ^ __Returns:__ a pointer to the reallocated memory

-- | A convenience synonym for @`Nothing` :: `Maybe` `ReallocFunc`@.
noReallocFunc :: Maybe ReallocFunc
noReallocFunc :: Maybe C_ReallocFunc
noReallocFunc = Maybe C_ReallocFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ReallocFunc :: MonadIO m => ReallocFunc -> m (GClosure C_ReallocFunc)
genClosure_ReallocFunc :: forall (m :: * -> *).
MonadIO m =>
C_ReallocFunc -> m (GClosure C_ReallocFunc)
genClosure_ReallocFunc C_ReallocFunc
cb = IO (GClosure C_ReallocFunc) -> m (GClosure C_ReallocFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ReallocFunc) -> m (GClosure C_ReallocFunc))
-> IO (GClosure C_ReallocFunc) -> m (GClosure C_ReallocFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ReallocFunc
cb' = Maybe (Ptr (FunPtr C_ReallocFunc))
-> C_ReallocFunc -> C_ReallocFunc
wrap_ReallocFunc Maybe (Ptr (FunPtr C_ReallocFunc))
forall a. Maybe a
Nothing C_ReallocFunc
cb
    C_ReallocFunc -> IO (FunPtr C_ReallocFunc)
mk_ReallocFunc C_ReallocFunc
cb' IO (FunPtr C_ReallocFunc)
-> (FunPtr C_ReallocFunc -> IO (GClosure C_ReallocFunc))
-> IO (GClosure C_ReallocFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ReallocFunc -> IO (GClosure C_ReallocFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ReallocFunc` into a `C_ReallocFunc`.
wrap_ReallocFunc :: 
    Maybe (Ptr (FunPtr C_ReallocFunc)) ->
    ReallocFunc ->
    C_ReallocFunc
wrap_ReallocFunc :: Maybe (Ptr (FunPtr C_ReallocFunc))
-> C_ReallocFunc -> C_ReallocFunc
wrap_ReallocFunc Maybe (Ptr (FunPtr C_ReallocFunc))
gi'funptrptr C_ReallocFunc
gi'cb Ptr ()
data_ CSize
size = do
    result <- C_ReallocFunc
gi'cb  Ptr ()
data_ CSize
size
    maybeReleaseFunPtr gi'funptrptr
    return result


-- callback PollableSourceFunc
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just "it should return %FALSE if the source should be removed."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "pollable_stream"
          , argType =
              TInterface Name { namespace = "GObject" , name = "Object" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the #GPollableInputStream or #GPollableOutputStream"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "data passed in by the user."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "This is the function type of the callback used for the #GSource\nreturned by g_pollable_input_stream_create_source() and\ng_pollable_output_stream_create_source()."
        , sinceVersion = Just "2.28"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_PollableSourceFunc =
    Ptr GObject.Object.Object ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "pollable_stream"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GPollableInputStream or #GPollableOutputStream"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data passed in by the user."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_PollableSourceFunc :: FunPtr C_PollableSourceFunc -> C_PollableSourceFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_PollableSourceFunc ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
    FunPtr C_PollableSourceFunc
    -> a
    -- ^ /@pollableStream@/: the t'GI.Gio.Interfaces.PollableInputStream.PollableInputStream' or t'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream'
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> m Bool
    -- ^ __Returns:__ it should return 'P.False' if the source should be removed.
dynamic_PollableSourceFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_PollableSourceFunc -> a -> Ptr () -> m Bool
dynamic_PollableSourceFunc FunPtr C_PollableSourceFunc
__funPtr a
pollableStream Ptr ()
data_ = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    pollableStream' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pollableStream
    result <- (__dynamic_C_PollableSourceFunc __funPtr) pollableStream' data_
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr pollableStream
    return result'

-- | Generate a function pointer callable from C code, from a `C_PollableSourceFunc`.
foreign import ccall "wrapper"
    mk_PollableSourceFunc :: C_PollableSourceFunc -> IO (FunPtr C_PollableSourceFunc)

-- | This is the function type of the callback used for the t'GI.GLib.Structs.Source.Source'
-- returned by 'GI.Gio.Interfaces.PollableInputStream.pollableInputStreamCreateSource' and
-- 'GI.Gio.Interfaces.PollableOutputStream.pollableOutputStreamCreateSource'.
-- 
-- /Since: 2.28/
type PollableSourceFunc =
    GObject.Object.Object
    -- ^ /@pollableStream@/: the t'GI.Gio.Interfaces.PollableInputStream.PollableInputStream' or t'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream'
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> IO Bool
    -- ^ __Returns:__ it should return 'P.False' if the source should be removed.

-- | A convenience synonym for @`Nothing` :: `Maybe` `PollableSourceFunc`@.
noPollableSourceFunc :: Maybe PollableSourceFunc
noPollableSourceFunc :: Maybe PollableSourceFunc
noPollableSourceFunc = Maybe PollableSourceFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_PollableSourceFunc :: MonadIO m => PollableSourceFunc -> m (GClosure C_PollableSourceFunc)
genClosure_PollableSourceFunc :: forall (m :: * -> *).
MonadIO m =>
PollableSourceFunc -> m (GClosure C_PollableSourceFunc)
genClosure_PollableSourceFunc PollableSourceFunc
cb = IO (GClosure C_PollableSourceFunc)
-> m (GClosure C_PollableSourceFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PollableSourceFunc)
 -> m (GClosure C_PollableSourceFunc))
-> IO (GClosure C_PollableSourceFunc)
-> m (GClosure C_PollableSourceFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PollableSourceFunc
cb' = Maybe (Ptr (FunPtr C_PollableSourceFunc))
-> PollableSourceFunc -> C_PollableSourceFunc
wrap_PollableSourceFunc Maybe (Ptr (FunPtr C_PollableSourceFunc))
forall a. Maybe a
Nothing PollableSourceFunc
cb
    C_PollableSourceFunc -> IO (FunPtr C_PollableSourceFunc)
mk_PollableSourceFunc C_PollableSourceFunc
cb' IO (FunPtr C_PollableSourceFunc)
-> (FunPtr C_PollableSourceFunc
    -> IO (GClosure C_PollableSourceFunc))
-> IO (GClosure C_PollableSourceFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PollableSourceFunc -> IO (GClosure C_PollableSourceFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PollableSourceFunc` into a `C_PollableSourceFunc`.
wrap_PollableSourceFunc :: 
    Maybe (Ptr (FunPtr C_PollableSourceFunc)) ->
    PollableSourceFunc ->
    C_PollableSourceFunc
wrap_PollableSourceFunc :: Maybe (Ptr (FunPtr C_PollableSourceFunc))
-> PollableSourceFunc -> C_PollableSourceFunc
wrap_PollableSourceFunc Maybe (Ptr (FunPtr C_PollableSourceFunc))
gi'funptrptr PollableSourceFunc
gi'cb Ptr Object
pollableStream Ptr ()
data_ = do
    pollableStream' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
pollableStream
    result <- gi'cb  pollableStream' data_
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback InputStreamClassSkipFinishFieldCallback
{- Callable
  { returnType = Just (TBasicType TSSize)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just "the size of the bytes skipped, or `-1` on error."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "result"
          , argType =
              TInterface Name { namespace = "Gio" , name = "AsyncResult" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassSkipFinishFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    Ptr Gio.AsyncResult.AsyncResult ->
    Ptr (Ptr GError) ->
    IO DI.Int64

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TSSize)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassSkipFinishFieldCallback :: FunPtr C_InputStreamClassSkipFinishFieldCallback -> C_InputStreamClassSkipFinishFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassSkipFinishFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
    FunPtr C_InputStreamClassSkipFinishFieldCallback
    -> a
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> m DI.Int64
    -- ^ __Returns:__ the size of the bytes skipped, or @-1@ on error. /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_InputStreamClassSkipFinishFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
FunPtr C_InputStreamClassSkipFinishFieldCallback
-> a -> b -> m Int64
dynamic_InputStreamClassSkipFinishFieldCallback FunPtr C_InputStreamClassSkipFinishFieldCallback
__funPtr a
stream b
result_ = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ (__dynamic_C_InputStreamClassSkipFinishFieldCallback __funPtr) stream' result_'
        touchManagedPtr stream
        touchManagedPtr result_
        return result
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassSkipFinishFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassSkipFinishFieldCallback :: C_InputStreamClassSkipFinishFieldCallback -> IO (FunPtr C_InputStreamClassSkipFinishFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassSkipFinishFieldCallback =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> Gio.AsyncResult.AsyncResult
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> IO DI.Int64
    -- ^ __Returns:__ the size of the bytes skipped, or @-1@ on error. /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassSkipFinishFieldCallback`@.
noInputStreamClassSkipFinishFieldCallback :: Maybe InputStreamClassSkipFinishFieldCallback
noInputStreamClassSkipFinishFieldCallback :: Maybe InputStreamClassSkipFinishFieldCallback
noInputStreamClassSkipFinishFieldCallback = Maybe InputStreamClassSkipFinishFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback InputStreamClassSkipFieldCallback
{- Callable
  { returnType = Just (TBasicType TSSize)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText = Just "Number of bytes skipped, or -1 on error"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "count"
          , argType = TBasicType TSize
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the number of bytes that will be skipped from the stream"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "optional #GCancellable object, %NULL to ignore."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassSkipFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    FCT.CSize ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO DI.Int64

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the number of bytes that will be skipped from the stream"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional #GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TSSize)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassSkipFieldCallback :: FunPtr C_InputStreamClassSkipFieldCallback -> C_InputStreamClassSkipFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassSkipFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_InputStreamClassSkipFieldCallback
    -> a
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> FCT.CSize
    -- ^ /@count@/: the number of bytes that will be skipped from the stream
    -> Maybe (b)
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> m DI.Int64
    -- ^ __Returns:__ Number of bytes skipped, or -1 on error /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_InputStreamClassSkipFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassSkipFieldCallback
-> a -> CSize -> Maybe b -> m Int64
dynamic_InputStreamClassSkipFieldCallback FunPtr C_InputStreamClassSkipFieldCallback
__funPtr a
stream CSize
count Maybe b
cancellable = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ (__dynamic_C_InputStreamClassSkipFieldCallback __funPtr) stream' count maybeCancellable
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return result
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassSkipFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassSkipFieldCallback :: C_InputStreamClassSkipFieldCallback -> IO (FunPtr C_InputStreamClassSkipFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassSkipFieldCallback =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> FCT.CSize
    -- ^ /@count@/: the number of bytes that will be skipped from the stream
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> IO DI.Int64
    -- ^ __Returns:__ Number of bytes skipped, or -1 on error /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassSkipFieldCallback`@.
noInputStreamClassSkipFieldCallback :: Maybe InputStreamClassSkipFieldCallback
noInputStreamClassSkipFieldCallback :: Maybe InputStreamClassSkipFieldCallback
noInputStreamClassSkipFieldCallback = Maybe InputStreamClassSkipFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback InputStreamClassSkipAsyncFieldCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GInputStream." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "count"
          , argType = TBasicType TSize
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the number of bytes that will be skipped from the stream"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "io_priority"
          , argType = TBasicType TInt
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the [I/O priority][io-priority] of the request"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "optional #GCancellable object, %NULL to ignore."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "callback"
          , argType =
              TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "a #GAsyncReadyCallback\n  to call when the request is satisfied"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeAsync
          , argClosure = 5
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "the data to pass to callback function"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassSkipAsyncFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    FCT.CSize ->
    Int32 ->
    Ptr Gio.Cancellable.Cancellable ->
    FunPtr C_AsyncReadyCallback ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GInputStream." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the number of bytes that will be skipped from the stream"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the [I/O priority][io-priority] of the request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional #GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GAsyncReadyCallback\n  to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassSkipAsyncFieldCallback :: FunPtr C_InputStreamClassSkipAsyncFieldCallback -> C_InputStreamClassSkipAsyncFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassSkipAsyncFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_InputStreamClassSkipAsyncFieldCallback
    -> a
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> FCT.CSize
    -- ^ /@count@/: the number of bytes that will be skipped from the stream
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request
    -> Maybe (b)
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Maybe (AsyncReadyCallback_WithClosures)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> Ptr ()
    -- ^ /@userData@/: the data to pass to callback function
    -> m ()
dynamic_InputStreamClassSkipAsyncFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassSkipAsyncFieldCallback
-> a
-> CSize
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback_WithClosures
-> Ptr ()
-> m ()
dynamic_InputStreamClassSkipAsyncFieldCallback FunPtr C_InputStreamClassSkipAsyncFieldCallback
__funPtr a
stream CSize
count Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback_WithClosures
callback Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Maybe AsyncReadyCallback_WithClosures
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
        Just AsyncReadyCallback_WithClosures
jCallback -> do
            ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr C_AsyncReadyCallback))
            jCallback' <- mk_AsyncReadyCallback (wrap_AsyncReadyCallback (Just ptrcallback) jCallback)
            poke ptrcallback jCallback'
            return jCallback'
    (__dynamic_C_InputStreamClassSkipAsyncFieldCallback __funPtr) stream' count ioPriority maybeCancellable maybeCallback userData
    touchManagedPtr stream
    whenJust cancellable touchManagedPtr
    return ()

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassSkipAsyncFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassSkipAsyncFieldCallback :: C_InputStreamClassSkipAsyncFieldCallback -> IO (FunPtr C_InputStreamClassSkipAsyncFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassSkipAsyncFieldCallback =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> FCT.CSize
    -- ^ /@count@/: the number of bytes that will be skipped from the stream
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Maybe AsyncReadyCallback_WithClosures
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassSkipAsyncFieldCallback`@.
noInputStreamClassSkipAsyncFieldCallback :: Maybe InputStreamClassSkipAsyncFieldCallback
noInputStreamClassSkipAsyncFieldCallback :: Maybe InputStreamClassSkipAsyncFieldCallback
noInputStreamClassSkipAsyncFieldCallback = Maybe InputStreamClassSkipAsyncFieldCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type InputStreamClassSkipAsyncFieldCallback_WithClosures =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> FCT.CSize
    -- ^ /@count@/: the number of bytes that will be skipped from the stream
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Maybe AsyncReadyCallback_WithClosures
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> Ptr ()
    -- ^ /@userData@/: the data to pass to callback function
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassSkipAsyncFieldCallback_WithClosures`@.
noInputStreamClassSkipAsyncFieldCallback_WithClosures :: Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
noInputStreamClassSkipAsyncFieldCallback_WithClosures :: Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
noInputStreamClassSkipAsyncFieldCallback_WithClosures = Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_InputStreamClassSkipAsyncFieldCallback :: InputStreamClassSkipAsyncFieldCallback -> InputStreamClassSkipAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassSkipAsyncFieldCallback :: InputStreamClassSkipAsyncFieldCallback
-> InputStreamClassSkipAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassSkipAsyncFieldCallback InputStreamClassSkipAsyncFieldCallback
_f InputStream
stream CSize
count Int32
ioPriority Maybe Cancellable
cancellable Maybe AsyncReadyCallback_WithClosures
callback Ptr ()
_ = InputStreamClassSkipAsyncFieldCallback
_f InputStream
stream CSize
count Int32
ioPriority Maybe Cancellable
cancellable Maybe AsyncReadyCallback_WithClosures
callback

-- | Wrap the callback into a `GClosure`.
genClosure_InputStreamClassSkipAsyncFieldCallback :: MonadIO m => InputStreamClassSkipAsyncFieldCallback -> m (GClosure C_InputStreamClassSkipAsyncFieldCallback)
genClosure_InputStreamClassSkipAsyncFieldCallback :: forall (m :: * -> *).
MonadIO m =>
InputStreamClassSkipAsyncFieldCallback
-> m (GClosure C_InputStreamClassSkipAsyncFieldCallback)
genClosure_InputStreamClassSkipAsyncFieldCallback InputStreamClassSkipAsyncFieldCallback
cb = IO (GClosure C_InputStreamClassSkipAsyncFieldCallback)
-> m (GClosure C_InputStreamClassSkipAsyncFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputStreamClassSkipAsyncFieldCallback)
 -> m (GClosure C_InputStreamClassSkipAsyncFieldCallback))
-> IO (GClosure C_InputStreamClassSkipAsyncFieldCallback)
-> m (GClosure C_InputStreamClassSkipAsyncFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: InputStreamClassSkipAsyncFieldCallback_WithClosures
cb' = InputStreamClassSkipAsyncFieldCallback
-> InputStreamClassSkipAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassSkipAsyncFieldCallback InputStreamClassSkipAsyncFieldCallback
cb
    let cb'' :: C_InputStreamClassSkipAsyncFieldCallback
cb'' = Maybe (Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback))
-> InputStreamClassSkipAsyncFieldCallback_WithClosures
-> C_InputStreamClassSkipAsyncFieldCallback
wrap_InputStreamClassSkipAsyncFieldCallback Maybe (Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback))
forall a. Maybe a
Nothing InputStreamClassSkipAsyncFieldCallback_WithClosures
cb'
    C_InputStreamClassSkipAsyncFieldCallback
-> IO (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
mk_InputStreamClassSkipAsyncFieldCallback C_InputStreamClassSkipAsyncFieldCallback
cb'' IO (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
-> (FunPtr C_InputStreamClassSkipAsyncFieldCallback
    -> IO (GClosure C_InputStreamClassSkipAsyncFieldCallback))
-> IO (GClosure C_InputStreamClassSkipAsyncFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputStreamClassSkipAsyncFieldCallback
-> IO (GClosure C_InputStreamClassSkipAsyncFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputStreamClassSkipAsyncFieldCallback` into a `C_InputStreamClassSkipAsyncFieldCallback`.
wrap_InputStreamClassSkipAsyncFieldCallback :: 
    Maybe (Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)) ->
    InputStreamClassSkipAsyncFieldCallback_WithClosures ->
    C_InputStreamClassSkipAsyncFieldCallback
wrap_InputStreamClassSkipAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback))
-> InputStreamClassSkipAsyncFieldCallback_WithClosures
-> C_InputStreamClassSkipAsyncFieldCallback
wrap_InputStreamClassSkipAsyncFieldCallback Maybe (Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback))
gi'funptrptr InputStreamClassSkipAsyncFieldCallback_WithClosures
gi'cb Ptr InputStream
stream CSize
count Int32
ioPriority Ptr Cancellable
cancellable FunPtr C_AsyncReadyCallback
callback Ptr ()
userData = do
    stream' <- ((ManagedPtr InputStream -> InputStream)
-> Ptr InputStream -> IO InputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
stream
    maybeCancellable <-
        if cancellable == FP.nullPtr
        then return Nothing
        else do
            cancellable' <- (newObject Gio.Cancellable.Cancellable) cancellable
            return $ Just cancellable'
    maybeCallback <-
        if callback == FP.nullFunPtr
        then return Nothing
        else do
            let callback' = FunPtr C_AsyncReadyCallback -> AsyncReadyCallback_WithClosures
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsAsyncResult b) =>
FunPtr C_AsyncReadyCallback -> Maybe a -> b -> Ptr () -> m ()
dynamic_AsyncReadyCallback FunPtr C_AsyncReadyCallback
callback
            return $ Just callback'
    gi'cb  stream' count ioPriority maybeCancellable maybeCallback userData
    maybeReleaseFunPtr gi'funptrptr


-- callback InputStreamClassReadFnFieldCallback
{- Callable
  { returnType = Just (TBasicType TSSize)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "buffer"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "count"
          , argType = TBasicType TSize
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassReadFnFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    Ptr () ->
    FCT.CSize ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO DI.Int64

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "buffer"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TSSize)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassReadFnFieldCallback :: FunPtr C_InputStreamClassReadFnFieldCallback -> C_InputStreamClassReadFnFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassReadFnFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_InputStreamClassReadFnFieldCallback
    -> a
    -> Ptr ()
    -> FCT.CSize
    -> Maybe (b)
    -> m DI.Int64
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_InputStreamClassReadFnFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassReadFnFieldCallback
-> a -> Ptr () -> CSize -> Maybe b -> m Int64
dynamic_InputStreamClassReadFnFieldCallback FunPtr C_InputStreamClassReadFnFieldCallback
__funPtr a
stream Ptr ()
buffer CSize
count Maybe b
cancellable = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ (__dynamic_C_InputStreamClassReadFnFieldCallback __funPtr) stream' buffer count maybeCancellable
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return result
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassReadFnFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassReadFnFieldCallback :: C_InputStreamClassReadFnFieldCallback -> IO (FunPtr C_InputStreamClassReadFnFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassReadFnFieldCallback =
    Gio.InputStream.InputStream
    -> Ptr ()
    -> FCT.CSize
    -> Maybe Gio.Cancellable.Cancellable
    -> IO DI.Int64
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassReadFnFieldCallback`@.
noInputStreamClassReadFnFieldCallback :: Maybe InputStreamClassReadFnFieldCallback
noInputStreamClassReadFnFieldCallback :: Maybe InputStreamClassReadFnFieldCallback
noInputStreamClassReadFnFieldCallback = Maybe InputStreamClassReadFnFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback InputStreamClassReadFinishFieldCallback
{- Callable
  { returnType = Just (TBasicType TSSize)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "number of bytes read in, or -1 on error, or 0 on end of file."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "result"
          , argType =
              TInterface Name { namespace = "Gio" , name = "AsyncResult" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassReadFinishFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    Ptr Gio.AsyncResult.AsyncResult ->
    Ptr (Ptr GError) ->
    IO DI.Int64

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TSSize)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassReadFinishFieldCallback :: FunPtr C_InputStreamClassReadFinishFieldCallback -> C_InputStreamClassReadFinishFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassReadFinishFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
    FunPtr C_InputStreamClassReadFinishFieldCallback
    -> a
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> m DI.Int64
    -- ^ __Returns:__ number of bytes read in, or -1 on error, or 0 on end of file. /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_InputStreamClassReadFinishFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
FunPtr C_InputStreamClassSkipFinishFieldCallback
-> a -> b -> m Int64
dynamic_InputStreamClassReadFinishFieldCallback FunPtr C_InputStreamClassSkipFinishFieldCallback
__funPtr a
stream b
result_ = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ (__dynamic_C_InputStreamClassReadFinishFieldCallback __funPtr) stream' result_'
        touchManagedPtr stream
        touchManagedPtr result_
        return result
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassReadFinishFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassReadFinishFieldCallback :: C_InputStreamClassReadFinishFieldCallback -> IO (FunPtr C_InputStreamClassReadFinishFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassReadFinishFieldCallback =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> Gio.AsyncResult.AsyncResult
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> IO DI.Int64
    -- ^ __Returns:__ number of bytes read in, or -1 on error, or 0 on end of file. /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassReadFinishFieldCallback`@.
noInputStreamClassReadFinishFieldCallback :: Maybe InputStreamClassReadFinishFieldCallback
noInputStreamClassReadFinishFieldCallback :: Maybe InputStreamClassSkipFinishFieldCallback
noInputStreamClassReadFinishFieldCallback = Maybe InputStreamClassSkipFinishFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback InputStreamClassReadAsyncFieldCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GInputStream." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "buffer"
          , argType = TCArray False (-1) 2 (TBasicType TUInt8)
          , direction = DirectionInout
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "\n    a buffer to read data into (which should be at least count bytes long)."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = True
          , argCallbackUserData = False
          , transfer = TransferEverything
          }
      , Arg
          { argCName = "count"
          , argType = TBasicType TSize
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the number of bytes that will be read from the stream"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "io_priority"
          , argType = TBasicType TInt
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the [I/O priority][io-priority]\nof the request."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "optional #GCancellable object, %NULL to ignore."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "callback"
          , argType =
              TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "a #GAsyncReadyCallback\n  to call when the request is satisfied"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeAsync
          , argClosure = 6
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "the data to pass to callback function"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassReadAsyncFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    Ptr Word8 ->
    FCT.CSize ->
    Int32 ->
    Ptr Gio.Cancellable.Cancellable ->
    FunPtr C_AsyncReadyCallback ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GInputStream." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "buffer"
--           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "\n    a buffer to read data into (which should be at least count bytes long)."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "count"
--           , argType = TBasicType TSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the number of bytes that will be read from the stream"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the [I/O priority][io-priority]\nof the request."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional #GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GAsyncReadyCallback\n  to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 6
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "count"
--              , argType = TBasicType TSize
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just "the number of bytes that will be read from the stream"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassReadAsyncFieldCallback :: FunPtr C_InputStreamClassReadAsyncFieldCallback -> C_InputStreamClassReadAsyncFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassReadAsyncFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_InputStreamClassReadAsyncFieldCallback
    -> a
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> Maybe (ByteString)
    -- ^ /@buffer@/: 
    --     a buffer to read data into (which should be at least count bytes long).
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority]
    -- of the request.
    -> Maybe (b)
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Maybe (AsyncReadyCallback_WithClosures)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> Ptr ()
    -- ^ /@userData@/: the data to pass to callback function
    -> m ((Maybe ByteString))
dynamic_InputStreamClassReadAsyncFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassReadAsyncFieldCallback
-> a
-> Maybe ByteString
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback_WithClosures
-> Ptr ()
-> m (Maybe ByteString)
dynamic_InputStreamClassReadAsyncFieldCallback FunPtr C_InputStreamClassReadAsyncFieldCallback
__funPtr a
stream Maybe ByteString
buffer Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback_WithClosures
callback Ptr ()
userData = IO (Maybe ByteString) -> m (Maybe ByteString)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ByteString) -> m (Maybe ByteString))
-> IO (Maybe ByteString) -> m (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ do
    let count :: CSize
count = case Maybe ByteString
buffer of
            Maybe ByteString
Nothing -> CSize
0
            Just ByteString
jBuffer -> Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
jBuffer
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    maybeBuffer <- case buffer of
        Maybe ByteString
Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
FP.nullPtr
        Just ByteString
jBuffer -> do
            jBuffer' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jBuffer
            return jBuffer'
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Maybe AsyncReadyCallback_WithClosures
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
        Just AsyncReadyCallback_WithClosures
jCallback -> do
            ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr C_AsyncReadyCallback))
            jCallback' <- mk_AsyncReadyCallback (wrap_AsyncReadyCallback (Just ptrcallback) jCallback)
            poke ptrcallback jCallback'
            return jCallback'
    (__dynamic_C_InputStreamClassReadAsyncFieldCallback __funPtr) stream' maybeBuffer count ioPriority maybeCancellable maybeCallback userData
    maybeMaybeBuffer <- convertIfNonNull maybeBuffer $ \Ptr Word8
maybeBuffer' -> do
        maybeBuffer'' <- (CSize -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength CSize
count) Ptr Word8
maybeBuffer'
        freeMem maybeBuffer'
        return maybeBuffer''
    touchManagedPtr stream
    whenJust cancellable touchManagedPtr
    return maybeMaybeBuffer

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassReadAsyncFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassReadAsyncFieldCallback :: C_InputStreamClassReadAsyncFieldCallback -> IO (FunPtr C_InputStreamClassReadAsyncFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassReadAsyncFieldCallback =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> Maybe ByteString
    -- ^ /@buffer@/: 
    --     a buffer to read data into (which should be at least count bytes long).
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority]
    -- of the request.
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Maybe AsyncReadyCallback_WithClosures
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> IO ((Maybe ByteString))

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassReadAsyncFieldCallback`@.
noInputStreamClassReadAsyncFieldCallback :: Maybe InputStreamClassReadAsyncFieldCallback
noInputStreamClassReadAsyncFieldCallback :: Maybe InputStreamClassReadAsyncFieldCallback
noInputStreamClassReadAsyncFieldCallback = Maybe InputStreamClassReadAsyncFieldCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type InputStreamClassReadAsyncFieldCallback_WithClosures =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> Maybe ByteString
    -- ^ /@buffer@/: 
    --     a buffer to read data into (which should be at least count bytes long).
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority]
    -- of the request.
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Maybe AsyncReadyCallback_WithClosures
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> Ptr ()
    -- ^ /@userData@/: the data to pass to callback function
    -> IO ((Maybe ByteString))

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassReadAsyncFieldCallback_WithClosures`@.
noInputStreamClassReadAsyncFieldCallback_WithClosures :: Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
noInputStreamClassReadAsyncFieldCallback_WithClosures :: Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
noInputStreamClassReadAsyncFieldCallback_WithClosures = Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_InputStreamClassReadAsyncFieldCallback :: InputStreamClassReadAsyncFieldCallback -> InputStreamClassReadAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassReadAsyncFieldCallback :: InputStreamClassReadAsyncFieldCallback
-> InputStreamClassReadAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassReadAsyncFieldCallback InputStreamClassReadAsyncFieldCallback
_f InputStream
stream Maybe ByteString
buffer Int32
ioPriority Maybe Cancellable
cancellable Maybe AsyncReadyCallback_WithClosures
callback Ptr ()
_ = InputStreamClassReadAsyncFieldCallback
_f InputStream
stream Maybe ByteString
buffer Int32
ioPriority Maybe Cancellable
cancellable Maybe AsyncReadyCallback_WithClosures
callback

-- | Wrap the callback into a `GClosure`.
genClosure_InputStreamClassReadAsyncFieldCallback :: MonadIO m => InputStreamClassReadAsyncFieldCallback -> m (GClosure C_InputStreamClassReadAsyncFieldCallback)
genClosure_InputStreamClassReadAsyncFieldCallback :: forall (m :: * -> *).
MonadIO m =>
InputStreamClassReadAsyncFieldCallback
-> m (GClosure C_InputStreamClassReadAsyncFieldCallback)
genClosure_InputStreamClassReadAsyncFieldCallback InputStreamClassReadAsyncFieldCallback
cb = IO (GClosure C_InputStreamClassReadAsyncFieldCallback)
-> m (GClosure C_InputStreamClassReadAsyncFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputStreamClassReadAsyncFieldCallback)
 -> m (GClosure C_InputStreamClassReadAsyncFieldCallback))
-> IO (GClosure C_InputStreamClassReadAsyncFieldCallback)
-> m (GClosure C_InputStreamClassReadAsyncFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: InputStreamClassReadAsyncFieldCallback_WithClosures
cb' = InputStreamClassReadAsyncFieldCallback
-> InputStreamClassReadAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassReadAsyncFieldCallback InputStreamClassReadAsyncFieldCallback
cb
    let cb'' :: C_InputStreamClassReadAsyncFieldCallback
cb'' = Maybe (Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback))
-> InputStreamClassReadAsyncFieldCallback_WithClosures
-> C_InputStreamClassReadAsyncFieldCallback
wrap_InputStreamClassReadAsyncFieldCallback Maybe (Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback))
forall a. Maybe a
Nothing InputStreamClassReadAsyncFieldCallback_WithClosures
cb'
    C_InputStreamClassReadAsyncFieldCallback
-> IO (FunPtr C_InputStreamClassReadAsyncFieldCallback)
mk_InputStreamClassReadAsyncFieldCallback C_InputStreamClassReadAsyncFieldCallback
cb'' IO (FunPtr C_InputStreamClassReadAsyncFieldCallback)
-> (FunPtr C_InputStreamClassReadAsyncFieldCallback
    -> IO (GClosure C_InputStreamClassReadAsyncFieldCallback))
-> IO (GClosure C_InputStreamClassReadAsyncFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputStreamClassReadAsyncFieldCallback
-> IO (GClosure C_InputStreamClassReadAsyncFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputStreamClassReadAsyncFieldCallback` into a `C_InputStreamClassReadAsyncFieldCallback`.
wrap_InputStreamClassReadAsyncFieldCallback :: 
    Maybe (Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)) ->
    InputStreamClassReadAsyncFieldCallback_WithClosures ->
    C_InputStreamClassReadAsyncFieldCallback
wrap_InputStreamClassReadAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback))
-> InputStreamClassReadAsyncFieldCallback_WithClosures
-> C_InputStreamClassReadAsyncFieldCallback
wrap_InputStreamClassReadAsyncFieldCallback Maybe (Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback))
gi'funptrptr InputStreamClassReadAsyncFieldCallback_WithClosures
gi'cb Ptr InputStream
stream Ptr Word8
buffer CSize
count Int32
ioPriority Ptr Cancellable
cancellable FunPtr C_AsyncReadyCallback
callback Ptr ()
userData = do
    -- XXX Could not generate callback wrapper for InputStreamClassReadAsyncFieldCallback
    -- Not implemented: Don't know how to unpack C array of type TCArray False (-1) 2 (TBasicType TUInt8)
    String -> IO ()
forall a. HasCallStack => String -> a
P.error String
"The bindings for wrap_InputStreamClassReadAsyncFieldCallback could not be generated, function unsupported."


-- callback InputStreamClassCloseFnFieldCallback
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassCloseFnFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassCloseFnFieldCallback :: FunPtr C_InputStreamClassCloseFnFieldCallback -> C_InputStreamClassCloseFnFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassCloseFnFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_InputStreamClassCloseFnFieldCallback
    -> a
    -> Maybe (b)
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_InputStreamClassCloseFnFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassCloseFnFieldCallback
-> a -> Maybe b -> m ()
dynamic_InputStreamClassCloseFnFieldCallback FunPtr C_InputStreamClassCloseFnFieldCallback
__funPtr a
stream Maybe b
cancellable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ (__dynamic_C_InputStreamClassCloseFnFieldCallback __funPtr) stream' maybeCancellable
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassCloseFnFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassCloseFnFieldCallback :: C_InputStreamClassCloseFnFieldCallback -> IO (FunPtr C_InputStreamClassCloseFnFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassCloseFnFieldCallback =
    Gio.InputStream.InputStream
    -> Maybe Gio.Cancellable.Cancellable
    -> IO ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassCloseFnFieldCallback`@.
noInputStreamClassCloseFnFieldCallback :: Maybe InputStreamClassCloseFnFieldCallback
noInputStreamClassCloseFnFieldCallback :: Maybe InputStreamClassCloseFnFieldCallback
noInputStreamClassCloseFnFieldCallback = Maybe InputStreamClassCloseFnFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback InputStreamClassCloseFinishFieldCallback
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText = Just "%TRUE if the stream was closed successfully."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "result"
          , argType =
              TInterface Name { namespace = "Gio" , name = "AsyncResult" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = True
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassCloseFinishFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    Ptr Gio.AsyncResult.AsyncResult ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GInputStream." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassCloseFinishFieldCallback :: FunPtr C_InputStreamClassCloseFinishFieldCallback -> C_InputStreamClassCloseFinishFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassCloseFinishFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
    FunPtr C_InputStreamClassCloseFinishFieldCallback
    -> a
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
dynamic_InputStreamClassCloseFinishFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
FunPtr C_InputStreamClassCloseFinishFieldCallback -> a -> b -> m ()
dynamic_InputStreamClassCloseFinishFieldCallback FunPtr C_InputStreamClassCloseFinishFieldCallback
__funPtr a
stream b
result_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ (__dynamic_C_InputStreamClassCloseFinishFieldCallback __funPtr) stream' result_'
        touchManagedPtr stream
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassCloseFinishFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassCloseFinishFieldCallback :: C_InputStreamClassCloseFinishFieldCallback -> IO (FunPtr C_InputStreamClassCloseFinishFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassCloseFinishFieldCallback =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream'.
    -> Gio.AsyncResult.AsyncResult
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> IO ()
    -- ^ __Returns:__ 'P.True' if the stream was closed successfully. /(Can throw 'Data.GI.Base.GError.GError')/

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassCloseFinishFieldCallback`@.
noInputStreamClassCloseFinishFieldCallback :: Maybe InputStreamClassCloseFinishFieldCallback
noInputStreamClassCloseFinishFieldCallback :: Maybe InputStreamClassCloseFinishFieldCallback
noInputStreamClassCloseFinishFieldCallback = Maybe InputStreamClassCloseFinishFieldCallback
forall a. Maybe a
Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback InputStreamClassCloseAsyncFieldCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "stream"
          , argType =
              TInterface Name { namespace = "Gio" , name = "InputStream" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GInputStream." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "io_priority"
          , argType = TBasicType TInt
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the [I/O priority][io-priority] of the request"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "optional cancellable object"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "callback"
          , argType =
              TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "a #GAsyncReadyCallback\n  to call when the request is satisfied"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeAsync
          , argClosure = 4
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "the data to pass to callback function"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_InputStreamClassCloseAsyncFieldCallback =
    Ptr Gio.InputStream.InputStream ->
    Int32 ->
    Ptr Gio.Cancellable.Cancellable ->
    FunPtr C_AsyncReadyCallback ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GInputStream." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the [I/O priority][io-priority] of the request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "optional cancellable object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GAsyncReadyCallback\n  to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InputStreamClassCloseAsyncFieldCallback :: FunPtr C_InputStreamClassCloseAsyncFieldCallback -> C_InputStreamClassCloseAsyncFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InputStreamClassCloseAsyncFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_InputStreamClassCloseAsyncFieldCallback
    -> a
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request
    -> Maybe (b)
    -- ^ /@cancellable@/: optional cancellable object
    -> Maybe (AsyncReadyCallback_WithClosures)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> Ptr ()
    -- ^ /@userData@/: the data to pass to callback function
    -> m ()
dynamic_InputStreamClassCloseAsyncFieldCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassCloseAsyncFieldCallback
-> a
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback_WithClosures
-> Ptr ()
-> m ()
dynamic_InputStreamClassCloseAsyncFieldCallback FunPtr C_InputStreamClassCloseAsyncFieldCallback
__funPtr a
stream Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback_WithClosures
callback Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Maybe AsyncReadyCallback_WithClosures
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
        Just AsyncReadyCallback_WithClosures
jCallback -> do
            ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr C_AsyncReadyCallback))
            jCallback' <- mk_AsyncReadyCallback (wrap_AsyncReadyCallback (Just ptrcallback) jCallback)
            poke ptrcallback jCallback'
            return jCallback'
    (__dynamic_C_InputStreamClassCloseAsyncFieldCallback __funPtr) stream' ioPriority maybeCancellable maybeCallback userData
    touchManagedPtr stream
    whenJust cancellable touchManagedPtr
    return ()

-- | Generate a function pointer callable from C code, from a `C_InputStreamClassCloseAsyncFieldCallback`.
foreign import ccall "wrapper"
    mk_InputStreamClassCloseAsyncFieldCallback :: C_InputStreamClassCloseAsyncFieldCallback -> IO (FunPtr C_InputStreamClassCloseAsyncFieldCallback)

-- | /No description available in the introspection data./
type InputStreamClassCloseAsyncFieldCallback =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional cancellable object
    -> Maybe AsyncReadyCallback_WithClosures
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassCloseAsyncFieldCallback`@.
noInputStreamClassCloseAsyncFieldCallback :: Maybe InputStreamClassCloseAsyncFieldCallback
noInputStreamClassCloseAsyncFieldCallback :: Maybe InputStreamClassCloseAsyncFieldCallback
noInputStreamClassCloseAsyncFieldCallback = Maybe InputStreamClassCloseAsyncFieldCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type InputStreamClassCloseAsyncFieldCallback_WithClosures =
    Gio.InputStream.InputStream
    -- ^ /@stream@/: A t'GI.Gio.Objects.InputStream.InputStream'.
    -> Int32
    -- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional cancellable object
    -> Maybe AsyncReadyCallback_WithClosures
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
    --   to call when the request is satisfied
    -> Ptr ()
    -- ^ /@userData@/: the data to pass to callback function
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputStreamClassCloseAsyncFieldCallback_WithClosures`@.
noInputStreamClassCloseAsyncFieldCallback_WithClosures :: Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
noInputStreamClassCloseAsyncFieldCallback_WithClosures :: Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
noInputStreamClassCloseAsyncFieldCallback_WithClosures = Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_InputStreamClassCloseAsyncFieldCallback :: InputStreamClassCloseAsyncFieldCallback -> InputStreamClassCloseAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassCloseAsyncFieldCallback :: InputStreamClassCloseAsyncFieldCallback
-> InputStreamClassCloseAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassCloseAsyncFieldCallback InputStreamClassCloseAsyncFieldCallback
_f InputStream
stream Int32
ioPriority Maybe Cancellable
cancellable Maybe AsyncReadyCallback_WithClosures
callback Ptr ()
_ = InputStreamClassCloseAsyncFieldCallback
_f InputStream
stream Int32
ioPriority Maybe Cancellable
cancellable Maybe AsyncReadyCallback_WithClosures
callback

-- | Wrap the callback into a `GClosure`.
genClosure_InputStreamClassCloseAsyncFieldCallback :: MonadIO m => InputStreamClassCloseAsyncFieldCallback -> m (GClosure C_InputStreamClassCloseAsyncFieldCallback)
genClosure_InputStreamClassCloseAsyncFieldCallback :: forall (m :: * -> *).
MonadIO m =>
InputStreamClassCloseAsyncFieldCallback
-> m (GClosure C_InputStreamClassCloseAsyncFieldCallback)
genClosure_InputStreamClassCloseAsyncFieldCallback InputStreamClassCloseAsyncFieldCallback
cb = IO (GClosure C_InputStreamClassCloseAsyncFieldCallback)
-> m (GClosure C_InputStreamClassCloseAsyncFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputStreamClassCloseAsyncFieldCallback)
 -> m (GClosure C_InputStreamClassCloseAsyncFieldCallback))
-> IO (GClosure C_InputStreamClassCloseAsyncFieldCallback)
-> m (GClosure C_InputStreamClassCloseAsyncFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: InputStreamClassCloseAsyncFieldCallback_WithClosures
cb' = InputStreamClassCloseAsyncFieldCallback
-> InputStreamClassCloseAsyncFieldCallback_WithClosures
drop_closures_InputStreamClassCloseAsyncFieldCallback InputStreamClassCloseAsyncFieldCallback
cb
    let cb'' :: C_InputStreamClassCloseAsyncFieldCallback
cb'' = Maybe (Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback))
-> InputStreamClassCloseAsyncFieldCallback_WithClosures
-> C_InputStreamClassCloseAsyncFieldCallback
wrap_InputStreamClassCloseAsyncFieldCallback Maybe (Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback))
forall a. Maybe a
Nothing InputStreamClassCloseAsyncFieldCallback_WithClosures
cb'
    C_InputStreamClassCloseAsyncFieldCallback
-> IO (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
mk_InputStreamClassCloseAsyncFieldCallback C_InputStreamClassCloseAsyncFieldCallback
cb'' IO (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
-> (FunPtr C_InputStreamClassCloseAsyncFieldCallback
    -> IO (GClosure C_InputStreamClassCloseAsyncFieldCallback))
-> IO (GClosure C_InputStreamClassCloseAsyncFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputStreamClassCloseAsyncFieldCallback
-> IO (GClosure C_InputStreamClassCloseAsyncFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputStreamClassCloseAsyncFieldCallback` into a `C_InputStreamClassCloseAsyncFieldCallback`.
wrap_InputStreamClassCloseAsyncFieldCallback :: 
    Maybe (Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)) ->
    InputStreamClassCloseAsyncFieldCallback_WithClosures ->
    C_InputStreamClassCloseAsyncFieldCallback
wrap_InputStreamClassCloseAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback))
-> InputStreamClassCloseAsyncFieldCallback_WithClosures
-> C_InputStreamClassCloseAsyncFieldCallback
wrap_InputStreamClassCloseAsyncFieldCallback Maybe (Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback))
gi'funptrptr InputStreamClassCloseAsyncFieldCallback_WithClosures
gi'cb Ptr InputStream
stream Int32
ioPriority Ptr Cancellable
cancellable FunPtr C_AsyncReadyCallback
callback Ptr ()
userData = do
    stream' <- ((ManagedPtr InputStream -> InputStream)
-> Ptr InputStream -> IO InputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
stream
    maybeCancellable <-
        if cancellable == FP.nullPtr
        then return Nothing
        else do
            cancellable' <- (newObject Gio.Cancellable.Cancellable) cancellable
            return $ Just cancellable'
    maybeCallback <-
        if callback == FP.nullFunPtr
        then return Nothing
        else do
            let callback' = FunPtr C_AsyncReadyCallback -> AsyncReadyCallback_WithClosures
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsAsyncResult b) =>
FunPtr C_AsyncReadyCallback -> Maybe a -> b -> Ptr () -> m ()
dynamic_AsyncReadyCallback FunPtr C_AsyncReadyCallback
callback
            return $ Just callback'
    gi'cb  stream' ioPriority maybeCancellable maybeCallback userData
    maybeReleaseFunPtr gi'funptrptr


-- callback IOSchedulerJobFunc
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "%TRUE if this function should be called again to\n   complete the job, %FALSE if the job is complete (or cancelled)"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "job"
          , argType =
              TInterface Name { namespace = "Gio" , name = "IOSchedulerJob" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GIOSchedulerJob."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "optional #GCancellable object, %NULL to ignore."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "data passed to the callback function"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated =
      Just
        DeprecationInfo
          { deprecatedSinceVersion = Just "2.36"
          , deprecationMessage =
              Just
                "Use [struct@GLib.ThreadPool] or\n  [method@Gio.Task.run_in_thread]"
          }
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "I/O Job function.\n\nLong-running jobs should periodically check the @cancellable\nto see if they have been cancelled."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_IOSchedulerJobFunc =
    Ptr Gio.IOSchedulerJob.IOSchedulerJob ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "job"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "IOSchedulerJob" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GIOSchedulerJob."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional #GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data passed to the callback function"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_IOSchedulerJobFunc :: FunPtr C_IOSchedulerJobFunc -> C_IOSchedulerJobFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_IOSchedulerJobFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    FunPtr C_IOSchedulerJobFunc
    -> Gio.IOSchedulerJob.IOSchedulerJob
    -- ^ /@job@/: a t'GI.Gio.Structs.IOSchedulerJob.IOSchedulerJob'.
    -> Maybe (a)
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Ptr ()
    -- ^ /@data@/: data passed to the callback function
    -> m Bool
    -- ^ __Returns:__ 'P.True' if this function should be called again to
    --    complete the job, 'P.False' if the job is complete (or cancelled)
dynamic_IOSchedulerJobFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
FunPtr C_IOSchedulerJobFunc
-> IOSchedulerJob -> Maybe a -> Ptr () -> m Bool
dynamic_IOSchedulerJobFunc FunPtr C_IOSchedulerJobFunc
__funPtr IOSchedulerJob
job Maybe a
cancellable Ptr ()
data_ = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    job' <- IOSchedulerJob -> IO (Ptr IOSchedulerJob)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IOSchedulerJob
job
    maybeCancellable <- case cancellable of
        Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just a
jCancellable -> do
            jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            return jCancellable'
    result <- (__dynamic_C_IOSchedulerJobFunc __funPtr) job' maybeCancellable data_
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr job
    whenJust cancellable touchManagedPtr
    return result'

-- | Generate a function pointer callable from C code, from a `C_IOSchedulerJobFunc`.
foreign import ccall "wrapper"
    mk_IOSchedulerJobFunc :: C_IOSchedulerJobFunc -> IO (FunPtr C_IOSchedulerJobFunc)

{-# DEPRECATED IOSchedulerJobFunc ["(Since version 2.36)","Use [struct/@gLib@/.ThreadPool] or","  'GI.Gio.Objects.Task.taskRunInThread'"] #-}
-- | I\/O Job function.
-- 
-- Long-running jobs should periodically check the /@cancellable@/
-- to see if they have been cancelled.
type IOSchedulerJobFunc =
    Gio.IOSchedulerJob.IOSchedulerJob
    -- ^ /@job@/: a t'GI.Gio.Structs.IOSchedulerJob.IOSchedulerJob'.
    -> Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: optional t'GI.Gio.Objects.Cancellable.Cancellable' object, 'P.Nothing' to ignore.
    -> Ptr ()
    -- ^ /@data@/: data passed to the callback function
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if this function should be called again to
    --    complete the job, 'P.False' if the job is complete (or cancelled)

-- | A convenience synonym for @`Nothing` :: `Maybe` `IOSchedulerJobFunc`@.
noIOSchedulerJobFunc :: Maybe IOSchedulerJobFunc
noIOSchedulerJobFunc :: Maybe IOSchedulerJobFunc
noIOSchedulerJobFunc = Maybe IOSchedulerJobFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_IOSchedulerJobFunc :: MonadIO m => IOSchedulerJobFunc -> m (GClosure C_IOSchedulerJobFunc)
genClosure_IOSchedulerJobFunc :: forall (m :: * -> *).
MonadIO m =>
IOSchedulerJobFunc -> m (GClosure C_IOSchedulerJobFunc)
genClosure_IOSchedulerJobFunc IOSchedulerJobFunc
cb = IO (GClosure C_IOSchedulerJobFunc)
-> m (GClosure C_IOSchedulerJobFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_IOSchedulerJobFunc)
 -> m (GClosure C_IOSchedulerJobFunc))
-> IO (GClosure C_IOSchedulerJobFunc)
-> m (GClosure C_IOSchedulerJobFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_IOSchedulerJobFunc
cb' = Maybe (Ptr (FunPtr C_IOSchedulerJobFunc))
-> IOSchedulerJobFunc -> C_IOSchedulerJobFunc
wrap_IOSchedulerJobFunc Maybe (Ptr (FunPtr C_IOSchedulerJobFunc))
forall a. Maybe a
Nothing IOSchedulerJobFunc
cb
    C_IOSchedulerJobFunc -> IO (FunPtr C_IOSchedulerJobFunc)
mk_IOSchedulerJobFunc C_IOSchedulerJobFunc
cb' IO (FunPtr C_IOSchedulerJobFunc)
-> (FunPtr C_IOSchedulerJobFunc
    -> IO (GClosure C_IOSchedulerJobFunc))
-> IO (GClosure C_IOSchedulerJobFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_IOSchedulerJobFunc -> IO (GClosure C_IOSchedulerJobFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `IOSchedulerJobFunc` into a `C_IOSchedulerJobFunc`.
wrap_IOSchedulerJobFunc :: 
    Maybe (Ptr (FunPtr C_IOSchedulerJobFunc)) ->
    IOSchedulerJobFunc ->
    C_IOSchedulerJobFunc
wrap_IOSchedulerJobFunc :: Maybe (Ptr (FunPtr C_IOSchedulerJobFunc))
-> IOSchedulerJobFunc -> C_IOSchedulerJobFunc
wrap_IOSchedulerJobFunc Maybe (Ptr (FunPtr C_IOSchedulerJobFunc))
gi'funptrptr IOSchedulerJobFunc
gi'cb Ptr IOSchedulerJob
job Ptr Cancellable
cancellable Ptr ()
data_ = do
    job' <- ((ManagedPtr IOSchedulerJob -> IOSchedulerJob)
-> Ptr IOSchedulerJob -> IO IOSchedulerJob
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr IOSchedulerJob -> IOSchedulerJob
Gio.IOSchedulerJob.IOSchedulerJob) Ptr IOSchedulerJob
job
    maybeCancellable <-
        if cancellable == FP.nullPtr
        then return Nothing
        else do
            cancellable' <- (newObject Gio.Cancellable.Cancellable) cancellable
            return $ Just cancellable'
    result <- gi'cb  job' maybeCancellable data_
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback FileReadMoreCallback
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just "%TRUE if more data should be read back. %FALSE otherwise."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "file_contents"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the data as currently read."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "file_size"
          , argType = TBasicType TInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the size of the data currently read."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "callback_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "data passed to the callback."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "When loading the partial contents of a file with g_file_load_partial_contents_async(),\nit may become necessary to determine if any more data from the file should be loaded.\nA #GFileReadMoreCallback function facilitates this by returning %TRUE if more data\nshould be read, or %FALSE otherwise."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_FileReadMoreCallback =
    CString ->
    Int64 ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "file_contents"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data as currently read."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file_size"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the size of the data currently read."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data passed to the callback."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_FileReadMoreCallback :: FunPtr C_FileReadMoreCallback -> C_FileReadMoreCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_FileReadMoreCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_FileReadMoreCallback
    -> T.Text
    -- ^ /@fileContents@/: the data as currently read.
    -> Int64
    -- ^ /@fileSize@/: the size of the data currently read.
    -> Ptr ()
    -- ^ /@callbackData@/: data passed to the callback.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if more data should be read back. 'P.False' otherwise.
dynamic_FileReadMoreCallback :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_FileReadMoreCallback -> Text -> Int64 -> Ptr () -> m Bool
dynamic_FileReadMoreCallback FunPtr C_FileReadMoreCallback
__funPtr Text
fileContents Int64
fileSize Ptr ()
callbackData = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    fileContents' <- Text -> IO CString
textToCString Text
fileContents
    result <- (__dynamic_C_FileReadMoreCallback __funPtr) fileContents' fileSize callbackData
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    freeMem fileContents'
    return result'

-- | Generate a function pointer callable from C code, from a `C_FileReadMoreCallback`.
foreign import ccall "wrapper"
    mk_FileReadMoreCallback :: C_FileReadMoreCallback -> IO (FunPtr C_FileReadMoreCallback)

-- | When loading the partial contents of a file with @/g_file_load_partial_contents_async()/@,
-- it may become necessary to determine if any more data from the file should be loaded.
-- A t'GI.Gio.Callbacks.FileReadMoreCallback' function facilitates this by returning 'P.True' if more data
-- should be read, or 'P.False' otherwise.
type FileReadMoreCallback =
    T.Text
    -- ^ /@fileContents@/: the data as currently read.
    -> Int64
    -- ^ /@fileSize@/: the size of the data currently read.
    -> Ptr ()
    -- ^ /@callbackData@/: data passed to the callback.
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if more data should be read back. 'P.False' otherwise.

-- | A convenience synonym for @`Nothing` :: `Maybe` `FileReadMoreCallback`@.
noFileReadMoreCallback :: Maybe FileReadMoreCallback
noFileReadMoreCallback :: Maybe FileReadMoreCallback
noFileReadMoreCallback = Maybe FileReadMoreCallback
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_FileReadMoreCallback :: MonadIO m => FileReadMoreCallback -> m (GClosure C_FileReadMoreCallback)
genClosure_FileReadMoreCallback :: forall (m :: * -> *).
MonadIO m =>
FileReadMoreCallback -> m (GClosure C_FileReadMoreCallback)
genClosure_FileReadMoreCallback FileReadMoreCallback
cb = IO (GClosure C_FileReadMoreCallback)
-> m (GClosure C_FileReadMoreCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_FileReadMoreCallback)
 -> m (GClosure C_FileReadMoreCallback))
-> IO (GClosure C_FileReadMoreCallback)
-> m (GClosure C_FileReadMoreCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_FileReadMoreCallback
cb' = Maybe (Ptr (FunPtr C_FileReadMoreCallback))
-> FileReadMoreCallback -> C_FileReadMoreCallback
wrap_FileReadMoreCallback Maybe (Ptr (FunPtr C_FileReadMoreCallback))
forall a. Maybe a
Nothing FileReadMoreCallback
cb
    C_FileReadMoreCallback -> IO (FunPtr C_FileReadMoreCallback)
mk_FileReadMoreCallback C_FileReadMoreCallback
cb' IO (FunPtr C_FileReadMoreCallback)
-> (FunPtr C_FileReadMoreCallback
    -> IO (GClosure C_FileReadMoreCallback))
-> IO (GClosure C_FileReadMoreCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_FileReadMoreCallback
-> IO (GClosure C_FileReadMoreCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `FileReadMoreCallback` into a `C_FileReadMoreCallback`.
wrap_FileReadMoreCallback :: 
    Maybe (Ptr (FunPtr C_FileReadMoreCallback)) ->
    FileReadMoreCallback ->
    C_FileReadMoreCallback
wrap_FileReadMoreCallback :: Maybe (Ptr (FunPtr C_FileReadMoreCallback))
-> FileReadMoreCallback -> C_FileReadMoreCallback
wrap_FileReadMoreCallback Maybe (Ptr (FunPtr C_FileReadMoreCallback))
gi'funptrptr FileReadMoreCallback
gi'cb CString
fileContents Int64
fileSize Ptr ()
callbackData = do
    fileContents' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
fileContents
    result <- gi'cb  fileContents' fileSize callbackData
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback FileProgressCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "current_num_bytes"
          , argType = TBasicType TInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the current number of bytes in the operation."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "total_num_bytes"
          , argType = TBasicType TInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the total number of bytes in the operation."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "user data passed to the callback."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "When doing file operations that may take a while, such as moving\na file or copying a file, a progress callback is used to pass how\nfar along that operation is to the application."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_FileProgressCallback =
    Int64 ->
    Int64 ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "current_num_bytes"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the current number of bytes in the operation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "total_num_bytes"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the total number of bytes in the operation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed to the callback."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_FileProgressCallback :: FunPtr C_FileProgressCallback -> C_FileProgressCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_FileProgressCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_FileProgressCallback
    -> Int64
    -- ^ /@currentNumBytes@/: the current number of bytes in the operation.
    -> Int64
    -- ^ /@totalNumBytes@/: the total number of bytes in the operation.
    -> Ptr ()
    -- ^ /@data@/: user data passed to the callback.
    -> m ()
dynamic_FileProgressCallback :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_FileProgressCallback -> Int64 -> Int64 -> Ptr () -> m ()
dynamic_FileProgressCallback FunPtr C_FileProgressCallback
__funPtr Int64
currentNumBytes Int64
totalNumBytes Ptr ()
data_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    (FunPtr C_FileProgressCallback -> C_FileProgressCallback
__dynamic_C_FileProgressCallback FunPtr C_FileProgressCallback
__funPtr) Int64
currentNumBytes Int64
totalNumBytes Ptr ()
data_
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Generate a function pointer callable from C code, from a `C_FileProgressCallback`.
foreign import ccall "wrapper"
    mk_FileProgressCallback :: C_FileProgressCallback -> IO (FunPtr C_FileProgressCallback)

-- | When doing file operations that may take a while, such as moving
-- a file or copying a file, a progress callback is used to pass how
-- far along that operation is to the application.
type FileProgressCallback =
    Int64
    -- ^ /@currentNumBytes@/: the current number of bytes in the operation.
    -> Int64
    -- ^ /@totalNumBytes@/: the total number of bytes in the operation.
    -> Ptr ()
    -- ^ /@data@/: user data passed to the callback.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `FileProgressCallback`@.
noFileProgressCallback :: Maybe FileProgressCallback
noFileProgressCallback :: Maybe C_FileProgressCallback
noFileProgressCallback = Maybe C_FileProgressCallback
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_FileProgressCallback :: MonadIO m => FileProgressCallback -> m (GClosure C_FileProgressCallback)
genClosure_FileProgressCallback :: forall (m :: * -> *).
MonadIO m =>
C_FileProgressCallback -> m (GClosure C_FileProgressCallback)
genClosure_FileProgressCallback C_FileProgressCallback
cb = IO (GClosure C_FileProgressCallback)
-> m (GClosure C_FileProgressCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_FileProgressCallback)
 -> m (GClosure C_FileProgressCallback))
-> IO (GClosure C_FileProgressCallback)
-> m (GClosure C_FileProgressCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_FileProgressCallback
cb' = Maybe (Ptr (FunPtr C_FileProgressCallback))
-> C_FileProgressCallback -> C_FileProgressCallback
wrap_FileProgressCallback Maybe (Ptr (FunPtr C_FileProgressCallback))
forall a. Maybe a
Nothing C_FileProgressCallback
cb
    C_FileProgressCallback -> IO (FunPtr C_FileProgressCallback)
mk_FileProgressCallback C_FileProgressCallback
cb' IO (FunPtr C_FileProgressCallback)
-> (FunPtr C_FileProgressCallback
    -> IO (GClosure C_FileProgressCallback))
-> IO (GClosure C_FileProgressCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_FileProgressCallback
-> IO (GClosure C_FileProgressCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `FileProgressCallback` into a `C_FileProgressCallback`.
wrap_FileProgressCallback :: 
    Maybe (Ptr (FunPtr C_FileProgressCallback)) ->
    FileProgressCallback ->
    C_FileProgressCallback
wrap_FileProgressCallback :: Maybe (Ptr (FunPtr C_FileProgressCallback))
-> C_FileProgressCallback -> C_FileProgressCallback
wrap_FileProgressCallback Maybe (Ptr (FunPtr C_FileProgressCallback))
gi'funptrptr C_FileProgressCallback
gi'cb Int64
currentNumBytes Int64
totalNumBytes Ptr ()
data_ = do
    C_FileProgressCallback
gi'cb  Int64
currentNumBytes Int64
totalNumBytes Ptr ()
data_
    Maybe (Ptr (FunPtr C_FileProgressCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_FileProgressCallback))
gi'funptrptr


-- callback FileMeasureProgressCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "reporting"
          , argType = TBasicType TBoolean
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "%TRUE if more reports will come"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "current_size"
          , argType = TBasicType TUInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the current cumulative size measurement"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "num_dirs"
          , argType = TBasicType TUInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the number of directories visited so far"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "num_files"
          , argType = TBasicType TUInt64
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the number of non-directory files encountered"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the data passed to the original request for this callback"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "This callback type is used by g_file_measure_disk_usage() to make\nperiodic progress reports when measuring the amount of disk spaced\nused by a directory.\n\nThese calls are made on a best-effort basis and not all types of\n#GFile will support them.  At the minimum, however, one call will\nalways be made immediately.\n\nIn the case that there is no support, @reporting will be set to\n%FALSE (and the other values undefined) and no further calls will be\nmade.  Otherwise, the @reporting will be %TRUE and the other values\nall-zeros during the first (immediate) call.  In this way, you can\nknow which type of progress UI to show without a delay.\n\nFor g_file_measure_disk_usage() the callback is made directly.  For\ng_file_measure_disk_usage_async() the callback is made via the\ndefault main context of the calling thread (ie: the same way that the\nfinal async result would be reported).\n\n@current_size is in the same units as requested by the operation (see\n%G_FILE_MEASURE_APPARENT_SIZE).\n\nThe frequency of the updates is implementation defined, but is\nideally about once every 200ms.\n\nThe last progress callback may or may not be equal to the final\nresult.  Always check the async result to get the final value."
        , sinceVersion = Just "2.38"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_FileMeasureProgressCallback =
    CInt ->
    Word64 ->
    Word64 ->
    Word64 ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "reporting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if more reports will come"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "current_size"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the current cumulative size measurement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "num_dirs"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of directories visited so far"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "num_files"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of non-directory files encountered"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the data passed to the original request for this callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_FileMeasureProgressCallback :: FunPtr C_FileMeasureProgressCallback -> C_FileMeasureProgressCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_FileMeasureProgressCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_FileMeasureProgressCallback
    -> Bool
    -- ^ /@reporting@/: 'P.True' if more reports will come
    -> Word64
    -- ^ /@currentSize@/: the current cumulative size measurement
    -> Word64
    -- ^ /@numDirs@/: the number of directories visited so far
    -> Word64
    -- ^ /@numFiles@/: the number of non-directory files encountered
    -> Ptr ()
    -- ^ /@data@/: the data passed to the original request for this callback
    -> m ()
dynamic_FileMeasureProgressCallback :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_FileMeasureProgressCallback
-> Bool -> Word64 -> Word64 -> Word64 -> Ptr () -> m ()
dynamic_FileMeasureProgressCallback FunPtr C_FileMeasureProgressCallback
__funPtr Bool
reporting Word64
currentSize Word64
numDirs Word64
numFiles Ptr ()
data_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let reporting' :: CInt
reporting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
reporting
    (FunPtr C_FileMeasureProgressCallback
-> C_FileMeasureProgressCallback
__dynamic_C_FileMeasureProgressCallback FunPtr C_FileMeasureProgressCallback
__funPtr) CInt
reporting' Word64
currentSize Word64
numDirs Word64
numFiles Ptr ()
data_
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Generate a function pointer callable from C code, from a `C_FileMeasureProgressCallback`.
foreign import ccall "wrapper"
    mk_FileMeasureProgressCallback :: C_FileMeasureProgressCallback -> IO (FunPtr C_FileMeasureProgressCallback)

-- | This callback type is used by 'GI.Gio.Interfaces.File.fileMeasureDiskUsage' to make
-- periodic progress reports when measuring the amount of disk spaced
-- used by a directory.
-- 
-- These calls are made on a best-effort basis and not all types of
-- t'GI.Gio.Interfaces.File.File' will support them.  At the minimum, however, one call will
-- always be made immediately.
-- 
-- In the case that there is no support, /@reporting@/ will be set to
-- 'P.False' (and the other values undefined) and no further calls will be
-- made.  Otherwise, the /@reporting@/ will be 'P.True' and the other values
-- all-zeros during the first (immediate) call.  In this way, you can
-- know which type of progress UI to show without a delay.
-- 
-- For 'GI.Gio.Interfaces.File.fileMeasureDiskUsage' the callback is made directly.  For
-- @/g_file_measure_disk_usage_async()/@ the callback is made via the
-- default main context of the calling thread (ie: the same way that the
-- final async result would be reported).
-- 
-- /@currentSize@/ is in the same units as requested by the operation (see
-- 'GI.Gio.Flags.FileMeasureFlagsApparentSize').
-- 
-- The frequency of the updates is implementation defined, but is
-- ideally about once every 200ms.
-- 
-- The last progress callback may or may not be equal to the final
-- result.  Always check the async result to get the final value.
-- 
-- /Since: 2.38/
type FileMeasureProgressCallback =
    Bool
    -- ^ /@reporting@/: 'P.True' if more reports will come
    -> Word64
    -- ^ /@currentSize@/: the current cumulative size measurement
    -> Word64
    -- ^ /@numDirs@/: the number of directories visited so far
    -> Word64
    -- ^ /@numFiles@/: the number of non-directory files encountered
    -> Ptr ()
    -- ^ /@data@/: the data passed to the original request for this callback
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `FileMeasureProgressCallback`@.
noFileMeasureProgressCallback :: Maybe FileMeasureProgressCallback
noFileMeasureProgressCallback :: Maybe FileMeasureProgressCallback
noFileMeasureProgressCallback = Maybe FileMeasureProgressCallback
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_FileMeasureProgressCallback :: MonadIO m => FileMeasureProgressCallback -> m (GClosure C_FileMeasureProgressCallback)
genClosure_FileMeasureProgressCallback :: forall (m :: * -> *).
MonadIO m =>
FileMeasureProgressCallback
-> m (GClosure C_FileMeasureProgressCallback)
genClosure_FileMeasureProgressCallback FileMeasureProgressCallback
cb = IO (GClosure C_FileMeasureProgressCallback)
-> m (GClosure C_FileMeasureProgressCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_FileMeasureProgressCallback)
 -> m (GClosure C_FileMeasureProgressCallback))
-> IO (GClosure C_FileMeasureProgressCallback)
-> m (GClosure C_FileMeasureProgressCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_FileMeasureProgressCallback
cb' = Maybe (Ptr (FunPtr C_FileMeasureProgressCallback))
-> FileMeasureProgressCallback -> C_FileMeasureProgressCallback
wrap_FileMeasureProgressCallback Maybe (Ptr (FunPtr C_FileMeasureProgressCallback))
forall a. Maybe a
Nothing FileMeasureProgressCallback
cb
    C_FileMeasureProgressCallback
-> IO (FunPtr C_FileMeasureProgressCallback)
mk_FileMeasureProgressCallback C_FileMeasureProgressCallback
cb' IO (FunPtr C_FileMeasureProgressCallback)
-> (FunPtr C_FileMeasureProgressCallback
    -> IO (GClosure C_FileMeasureProgressCallback))
-> IO (GClosure C_FileMeasureProgressCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_FileMeasureProgressCallback
-> IO (GClosure C_FileMeasureProgressCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `FileMeasureProgressCallback` into a `C_FileMeasureProgressCallback`.
wrap_FileMeasureProgressCallback :: 
    Maybe (Ptr (FunPtr C_FileMeasureProgressCallback)) ->
    FileMeasureProgressCallback ->
    C_FileMeasureProgressCallback
wrap_FileMeasureProgressCallback :: Maybe (Ptr (FunPtr C_FileMeasureProgressCallback))
-> FileMeasureProgressCallback -> C_FileMeasureProgressCallback
wrap_FileMeasureProgressCallback Maybe (Ptr (FunPtr C_FileMeasureProgressCallback))
gi'funptrptr FileMeasureProgressCallback
gi'cb CInt
reporting Word64
currentSize Word64
numDirs Word64
numFiles Ptr ()
data_ = do
    let reporting' :: Bool
reporting' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
reporting
    FileMeasureProgressCallback
gi'cb  Bool
reporting' Word64
currentSize Word64
numDirs Word64
numFiles Ptr ()
data_
    Maybe (Ptr (FunPtr C_FileMeasureProgressCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_FileMeasureProgressCallback))
gi'funptrptr


-- callback DesktopAppLaunchCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "appinfo"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DesktopAppInfo" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GDesktopAppInfo" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "pid"
          , argType = TBasicType TInt
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "Process identifier" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "User data" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "During invocation, g_desktop_app_info_launch_uris_as_manager() may\ncreate one or more child processes.  This callback is invoked once\nfor each, providing the process ID."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DesktopAppLaunchCallback =
    Ptr Gio.DesktopAppInfo.DesktopAppInfo ->
    Int32 ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "appinfo"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DesktopAppInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GDesktopAppInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pid"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Process identifier" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DesktopAppLaunchCallback :: FunPtr C_DesktopAppLaunchCallback -> C_DesktopAppLaunchCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DesktopAppLaunchCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DesktopAppInfo.IsDesktopAppInfo a) =>
    FunPtr C_DesktopAppLaunchCallback
    -> a
    -- ^ /@appinfo@/: a t'GI.Gio.Objects.DesktopAppInfo.DesktopAppInfo'
    -> Int32
    -- ^ /@pid@/: Process identifier
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> m ()
dynamic_DesktopAppLaunchCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDesktopAppInfo a) =>
FunPtr C_DesktopAppLaunchCallback -> a -> Int32 -> Ptr () -> m ()
dynamic_DesktopAppLaunchCallback FunPtr C_DesktopAppLaunchCallback
__funPtr a
appinfo Int32
pid Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    appinfo' <- a -> IO (Ptr DesktopAppInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
appinfo
    (__dynamic_C_DesktopAppLaunchCallback __funPtr) appinfo' pid userData
    touchManagedPtr appinfo
    return ()

-- | Generate a function pointer callable from C code, from a `C_DesktopAppLaunchCallback`.
foreign import ccall "wrapper"
    mk_DesktopAppLaunchCallback :: C_DesktopAppLaunchCallback -> IO (FunPtr C_DesktopAppLaunchCallback)

-- | During invocation, 'GI.Gio.Objects.DesktopAppInfo.desktopAppInfoLaunchUrisAsManager' may
-- create one or more child processes.  This callback is invoked once
-- for each, providing the process ID.
type DesktopAppLaunchCallback =
    Gio.DesktopAppInfo.DesktopAppInfo
    -- ^ /@appinfo@/: a t'GI.Gio.Objects.DesktopAppInfo.DesktopAppInfo'
    -> Int32
    -- ^ /@pid@/: Process identifier
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DesktopAppLaunchCallback`@.
noDesktopAppLaunchCallback :: Maybe DesktopAppLaunchCallback
noDesktopAppLaunchCallback :: Maybe DesktopAppLaunchCallback
noDesktopAppLaunchCallback = Maybe DesktopAppLaunchCallback
forall a. Maybe a
Nothing

-- | During invocation, 'GI.Gio.Objects.DesktopAppInfo.desktopAppInfoLaunchUrisAsManager' may
-- create one or more child processes.  This callback is invoked once
-- for each, providing the process ID.
type DesktopAppLaunchCallback_WithClosures =
    Gio.DesktopAppInfo.DesktopAppInfo
    -- ^ /@appinfo@/: a t'GI.Gio.Objects.DesktopAppInfo.DesktopAppInfo'
    -> Int32
    -- ^ /@pid@/: Process identifier
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DesktopAppLaunchCallback_WithClosures`@.
noDesktopAppLaunchCallback_WithClosures :: Maybe DesktopAppLaunchCallback_WithClosures
noDesktopAppLaunchCallback_WithClosures :: Maybe DesktopAppLaunchCallback_WithClosures
noDesktopAppLaunchCallback_WithClosures = Maybe DesktopAppLaunchCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DesktopAppLaunchCallback :: DesktopAppLaunchCallback -> DesktopAppLaunchCallback_WithClosures
drop_closures_DesktopAppLaunchCallback :: DesktopAppLaunchCallback -> DesktopAppLaunchCallback_WithClosures
drop_closures_DesktopAppLaunchCallback DesktopAppLaunchCallback
_f DesktopAppInfo
appinfo Int32
pid Ptr ()
_ = DesktopAppLaunchCallback
_f DesktopAppInfo
appinfo Int32
pid

-- | Wrap the callback into a `GClosure`.
genClosure_DesktopAppLaunchCallback :: MonadIO m => DesktopAppLaunchCallback -> m (GClosure C_DesktopAppLaunchCallback)
genClosure_DesktopAppLaunchCallback :: forall (m :: * -> *).
MonadIO m =>
DesktopAppLaunchCallback -> m (GClosure C_DesktopAppLaunchCallback)
genClosure_DesktopAppLaunchCallback DesktopAppLaunchCallback
cb = IO (GClosure C_DesktopAppLaunchCallback)
-> m (GClosure C_DesktopAppLaunchCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DesktopAppLaunchCallback)
 -> m (GClosure C_DesktopAppLaunchCallback))
-> IO (GClosure C_DesktopAppLaunchCallback)
-> m (GClosure C_DesktopAppLaunchCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DesktopAppLaunchCallback_WithClosures
cb' = DesktopAppLaunchCallback -> DesktopAppLaunchCallback_WithClosures
drop_closures_DesktopAppLaunchCallback DesktopAppLaunchCallback
cb
    let cb'' :: C_DesktopAppLaunchCallback
cb'' = Maybe (Ptr (FunPtr C_DesktopAppLaunchCallback))
-> DesktopAppLaunchCallback_WithClosures
-> C_DesktopAppLaunchCallback
wrap_DesktopAppLaunchCallback Maybe (Ptr (FunPtr C_DesktopAppLaunchCallback))
forall a. Maybe a
Nothing DesktopAppLaunchCallback_WithClosures
cb'
    C_DesktopAppLaunchCallback
-> IO (FunPtr C_DesktopAppLaunchCallback)
mk_DesktopAppLaunchCallback C_DesktopAppLaunchCallback
cb'' IO (FunPtr C_DesktopAppLaunchCallback)
-> (FunPtr C_DesktopAppLaunchCallback
    -> IO (GClosure C_DesktopAppLaunchCallback))
-> IO (GClosure C_DesktopAppLaunchCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DesktopAppLaunchCallback
-> IO (GClosure C_DesktopAppLaunchCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DesktopAppLaunchCallback` into a `C_DesktopAppLaunchCallback`.
wrap_DesktopAppLaunchCallback :: 
    Maybe (Ptr (FunPtr C_DesktopAppLaunchCallback)) ->
    DesktopAppLaunchCallback_WithClosures ->
    C_DesktopAppLaunchCallback
wrap_DesktopAppLaunchCallback :: Maybe (Ptr (FunPtr C_DesktopAppLaunchCallback))
-> DesktopAppLaunchCallback_WithClosures
-> C_DesktopAppLaunchCallback
wrap_DesktopAppLaunchCallback Maybe (Ptr (FunPtr C_DesktopAppLaunchCallback))
gi'funptrptr DesktopAppLaunchCallback_WithClosures
gi'cb Ptr DesktopAppInfo
appinfo Int32
pid Ptr ()
userData = do
    appinfo' <- ((ManagedPtr DesktopAppInfo -> DesktopAppInfo)
-> Ptr DesktopAppInfo -> IO DesktopAppInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DesktopAppInfo -> DesktopAppInfo
Gio.DesktopAppInfo.DesktopAppInfo) Ptr DesktopAppInfo
appinfo
    gi'cb  appinfo' pid userData
    maybeReleaseFunPtr gi'funptrptr


-- callback DatagramBasedSourceFunc
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "%G_SOURCE_REMOVE if the source should be removed,\n  %G_SOURCE_CONTINUE otherwise"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "datagram_based"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DatagramBased" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the #GDatagramBased"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "condition"
          , argType =
              TInterface Name { namespace = "GLib" , name = "IOCondition" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "the current condition at the source fired"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "data passed in by the user"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "This is the function type of the callback used for the #GSource\nreturned by g_datagram_based_create_source()."
        , sinceVersion = Just "2.48"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DatagramBasedSourceFunc =
    Ptr Gio.DatagramBased.DatagramBased ->
    CUInt ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "datagram_based"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DatagramBased" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GDatagramBased"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "condition"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "IOCondition" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the current condition at the source fired"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data passed in by the user"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DatagramBasedSourceFunc :: FunPtr C_DatagramBasedSourceFunc -> C_DatagramBasedSourceFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DatagramBasedSourceFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DatagramBased.IsDatagramBased a) =>
    FunPtr C_DatagramBasedSourceFunc
    -> a
    -- ^ /@datagramBased@/: the t'GI.Gio.Interfaces.DatagramBased.DatagramBased'
    -> [GLib.Flags.IOCondition]
    -- ^ /@condition@/: the current condition at the source fired
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user
    -> m Bool
    -- ^ __Returns:__ 'GI.GLib.Constants.SOURCE_REMOVE' if the source should be removed,
    --   'GI.GLib.Constants.SOURCE_CONTINUE' otherwise
dynamic_DatagramBasedSourceFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDatagramBased a) =>
FunPtr C_DatagramBasedSourceFunc
-> a -> [IOCondition] -> Ptr () -> m Bool
dynamic_DatagramBasedSourceFunc FunPtr C_DatagramBasedSourceFunc
__funPtr a
datagramBased [IOCondition]
condition Ptr ()
data_ = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    datagramBased' <- a -> IO (Ptr DatagramBased)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
datagramBased
    let condition' = [IOCondition] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [IOCondition]
condition
    result <- (__dynamic_C_DatagramBasedSourceFunc __funPtr) datagramBased' condition' data_
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr datagramBased
    return result'

-- | Generate a function pointer callable from C code, from a `C_DatagramBasedSourceFunc`.
foreign import ccall "wrapper"
    mk_DatagramBasedSourceFunc :: C_DatagramBasedSourceFunc -> IO (FunPtr C_DatagramBasedSourceFunc)

-- | This is the function type of the callback used for the t'GI.GLib.Structs.Source.Source'
-- returned by 'GI.Gio.Interfaces.DatagramBased.datagramBasedCreateSource'.
-- 
-- /Since: 2.48/
type DatagramBasedSourceFunc =
    Gio.DatagramBased.DatagramBased
    -- ^ /@datagramBased@/: the t'GI.Gio.Interfaces.DatagramBased.DatagramBased'
    -> [GLib.Flags.IOCondition]
    -- ^ /@condition@/: the current condition at the source fired
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user
    -> IO Bool
    -- ^ __Returns:__ 'GI.GLib.Constants.SOURCE_REMOVE' if the source should be removed,
    --   'GI.GLib.Constants.SOURCE_CONTINUE' otherwise

-- | A convenience synonym for @`Nothing` :: `Maybe` `DatagramBasedSourceFunc`@.
noDatagramBasedSourceFunc :: Maybe DatagramBasedSourceFunc
noDatagramBasedSourceFunc :: Maybe DatagramBasedSourceFunc
noDatagramBasedSourceFunc = Maybe DatagramBasedSourceFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_DatagramBasedSourceFunc :: MonadIO m => DatagramBasedSourceFunc -> m (GClosure C_DatagramBasedSourceFunc)
genClosure_DatagramBasedSourceFunc :: forall (m :: * -> *).
MonadIO m =>
DatagramBasedSourceFunc -> m (GClosure C_DatagramBasedSourceFunc)
genClosure_DatagramBasedSourceFunc DatagramBasedSourceFunc
cb = IO (GClosure C_DatagramBasedSourceFunc)
-> m (GClosure C_DatagramBasedSourceFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DatagramBasedSourceFunc)
 -> m (GClosure C_DatagramBasedSourceFunc))
-> IO (GClosure C_DatagramBasedSourceFunc)
-> m (GClosure C_DatagramBasedSourceFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_DatagramBasedSourceFunc
cb' = Maybe (Ptr (FunPtr C_DatagramBasedSourceFunc))
-> DatagramBasedSourceFunc -> C_DatagramBasedSourceFunc
wrap_DatagramBasedSourceFunc Maybe (Ptr (FunPtr C_DatagramBasedSourceFunc))
forall a. Maybe a
Nothing DatagramBasedSourceFunc
cb
    C_DatagramBasedSourceFunc -> IO (FunPtr C_DatagramBasedSourceFunc)
mk_DatagramBasedSourceFunc C_DatagramBasedSourceFunc
cb' IO (FunPtr C_DatagramBasedSourceFunc)
-> (FunPtr C_DatagramBasedSourceFunc
    -> IO (GClosure C_DatagramBasedSourceFunc))
-> IO (GClosure C_DatagramBasedSourceFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DatagramBasedSourceFunc
-> IO (GClosure C_DatagramBasedSourceFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DatagramBasedSourceFunc` into a `C_DatagramBasedSourceFunc`.
wrap_DatagramBasedSourceFunc :: 
    Maybe (Ptr (FunPtr C_DatagramBasedSourceFunc)) ->
    DatagramBasedSourceFunc ->
    C_DatagramBasedSourceFunc
wrap_DatagramBasedSourceFunc :: Maybe (Ptr (FunPtr C_DatagramBasedSourceFunc))
-> DatagramBasedSourceFunc -> C_DatagramBasedSourceFunc
wrap_DatagramBasedSourceFunc Maybe (Ptr (FunPtr C_DatagramBasedSourceFunc))
gi'funptrptr DatagramBasedSourceFunc
gi'cb Ptr DatagramBased
datagramBased CUInt
condition Ptr ()
data_ = do
    datagramBased' <- ((ManagedPtr DatagramBased -> DatagramBased)
-> Ptr DatagramBased -> IO DatagramBased
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DatagramBased -> DatagramBased
Gio.DatagramBased.DatagramBased) Ptr DatagramBased
datagramBased
    let condition' = CUInt -> [IOCondition]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
condition
    result <- gi'cb  datagramBased' condition' data_
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback DBusSubtreeIntrospectFunc
{- Callable
  { returnType =
      Just
        (TCArray
           True
           (-1)
           (-1)
           (TInterface
              Name { namespace = "Gio" , name = "DBusInterfaceInfo" }))
  , returnMayBeNull = True
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "A %NULL-terminated array of pointers to #GDBusInterfaceInfo, or %NULL."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "sender"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The unique bus name of the remote caller."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The object path that was registered with g_dbus_connection_register_subtree()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "node"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The @user_data #gpointer passed to g_dbus_connection_register_subtree()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of the @introspect function in #GDBusSubtreeVTable.\n\nSubtrees are flat.  @node, if non-%NULL, is always exactly one\nsegment of the object path (ie: it never contains a slash).\n\nThis function should return %NULL to indicate that there is no object\nat this node.\n\nIf this function returns non-%NULL, the return value is expected to\nbe a %NULL-terminated array of pointers to #GDBusInterfaceInfo\nstructures describing the interfaces implemented by @node.  This\narray will have g_dbus_interface_info_unref() called on each item\nbefore being freed with g_free().\n\nThe difference between returning %NULL and an array containing zero\nitems is that the standard DBus interfaces will returned to the\nremote introspector in the empty array case, but not in the %NULL\ncase."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusSubtreeIntrospectFunc =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    CString ->
    Ptr () ->
    IO (Ptr (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo))

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sender"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The unique bus name of the remote caller."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The object path that was registered with g_dbus_connection_register_subtree()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "node"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The @user_data #gpointer passed to g_dbus_connection_register_subtree()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TCArray
--                  True
--                  (-1)
--                  (-1)
--                  (TInterface
--                     Name { namespace = "Gio" , name = "DBusInterfaceInfo" }))
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusSubtreeIntrospectFunc :: FunPtr C_DBusSubtreeIntrospectFunc -> C_DBusSubtreeIntrospectFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusSubtreeIntrospectFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_DBusSubtreeIntrospectFunc
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> T.Text
    -- ^ /@node@/: A node that is a child of /@objectPath@/ (relative to /@objectPath@/) or 'P.Nothing' for the root of the subtree.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> m (Maybe [Gio.DBusInterfaceInfo.DBusInterfaceInfo])
    -- ^ __Returns:__ A 'P.Nothing'-terminated array of pointers to t'GI.Gio.Structs.DBusInterfaceInfo.DBusInterfaceInfo', or 'P.Nothing'.
dynamic_DBusSubtreeIntrospectFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_DBusSubtreeIntrospectFunc
-> a
-> Text
-> Text
-> Text
-> Ptr ()
-> m (Maybe [DBusInterfaceInfo])
dynamic_DBusSubtreeIntrospectFunc FunPtr C_DBusSubtreeIntrospectFunc
__funPtr a
connection Text
sender Text
objectPath Text
node Ptr ()
userData = IO (Maybe [DBusInterfaceInfo]) -> m (Maybe [DBusInterfaceInfo])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [DBusInterfaceInfo]) -> m (Maybe [DBusInterfaceInfo]))
-> IO (Maybe [DBusInterfaceInfo]) -> m (Maybe [DBusInterfaceInfo])
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    sender' <- textToCString sender
    objectPath' <- textToCString objectPath
    node' <- textToCString node
    result <- (__dynamic_C_DBusSubtreeIntrospectFunc __funPtr) connection' sender' objectPath' node' userData
    maybeResult <- convertIfNonNull result $ \Ptr (Ptr DBusInterfaceInfo)
result' -> do
        result'' <- Ptr (Ptr DBusInterfaceInfo) -> IO [Ptr DBusInterfaceInfo]
forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusInterfaceInfo)
result'
        result''' <- mapM (wrapBoxed Gio.DBusInterfaceInfo.DBusInterfaceInfo) result''
        freeMem result'
        return result'''
    touchManagedPtr connection
    freeMem sender'
    freeMem objectPath'
    freeMem node'
    return maybeResult

-- | Generate a function pointer callable from C code, from a `C_DBusSubtreeIntrospectFunc`.
foreign import ccall "wrapper"
    mk_DBusSubtreeIntrospectFunc :: C_DBusSubtreeIntrospectFunc -> IO (FunPtr C_DBusSubtreeIntrospectFunc)

-- | The type of the /@introspect@/ function in t'GI.Gio.Structs.DBusSubtreeVTable.DBusSubtreeVTable'.
-- 
-- Subtrees are flat.  /@node@/, if non-'P.Nothing', is always exactly one
-- segment of the object path (ie: it never contains a slash).
-- 
-- This function should return 'P.Nothing' to indicate that there is no object
-- at this node.
-- 
-- If this function returns non-'P.Nothing', the return value is expected to
-- be a 'P.Nothing'-terminated array of pointers to t'GI.Gio.Structs.DBusInterfaceInfo.DBusInterfaceInfo'
-- structures describing the interfaces implemented by /@node@/.  This
-- array will have 'GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoUnref' called on each item
-- before being freed with 'GI.GLib.Functions.free'.
-- 
-- The difference between returning 'P.Nothing' and an array containing zero
-- items is that the standard DBus interfaces will returned to the
-- remote introspector in the empty array case, but not in the 'P.Nothing'
-- case.
-- 
-- /Since: 2.26/
type DBusSubtreeIntrospectFunc =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> T.Text
    -- ^ /@node@/: A node that is a child of /@objectPath@/ (relative to /@objectPath@/) or 'P.Nothing' for the root of the subtree.
    -> IO (Maybe [Gio.DBusInterfaceInfo.DBusInterfaceInfo])
    -- ^ __Returns:__ A 'P.Nothing'-terminated array of pointers to t'GI.Gio.Structs.DBusInterfaceInfo.DBusInterfaceInfo', or 'P.Nothing'.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSubtreeIntrospectFunc`@.
noDBusSubtreeIntrospectFunc :: Maybe DBusSubtreeIntrospectFunc
noDBusSubtreeIntrospectFunc :: Maybe DBusSubtreeIntrospectFunc
noDBusSubtreeIntrospectFunc = Maybe DBusSubtreeIntrospectFunc
forall a. Maybe a
Nothing

-- | The type of the /@introspect@/ function in t'GI.Gio.Structs.DBusSubtreeVTable.DBusSubtreeVTable'.
-- 
-- Subtrees are flat.  /@node@/, if non-'P.Nothing', is always exactly one
-- segment of the object path (ie: it never contains a slash).
-- 
-- This function should return 'P.Nothing' to indicate that there is no object
-- at this node.
-- 
-- If this function returns non-'P.Nothing', the return value is expected to
-- be a 'P.Nothing'-terminated array of pointers to t'GI.Gio.Structs.DBusInterfaceInfo.DBusInterfaceInfo'
-- structures describing the interfaces implemented by /@node@/.  This
-- array will have 'GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoUnref' called on each item
-- before being freed with 'GI.GLib.Functions.free'.
-- 
-- The difference between returning 'P.Nothing' and an array containing zero
-- items is that the standard DBus interfaces will returned to the
-- remote introspector in the empty array case, but not in the 'P.Nothing'
-- case.
-- 
-- /Since: 2.26/
type DBusSubtreeIntrospectFunc_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> T.Text
    -- ^ /@node@/: A node that is a child of /@objectPath@/ (relative to /@objectPath@/) or 'P.Nothing' for the root of the subtree.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> IO (Maybe [Gio.DBusInterfaceInfo.DBusInterfaceInfo])
    -- ^ __Returns:__ A 'P.Nothing'-terminated array of pointers to t'GI.Gio.Structs.DBusInterfaceInfo.DBusInterfaceInfo', or 'P.Nothing'.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSubtreeIntrospectFunc_WithClosures`@.
noDBusSubtreeIntrospectFunc_WithClosures :: Maybe DBusSubtreeIntrospectFunc_WithClosures
noDBusSubtreeIntrospectFunc_WithClosures :: Maybe DBusSubtreeIntrospectFunc_WithClosures
noDBusSubtreeIntrospectFunc_WithClosures = Maybe DBusSubtreeIntrospectFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusSubtreeIntrospectFunc :: DBusSubtreeIntrospectFunc -> DBusSubtreeIntrospectFunc_WithClosures
drop_closures_DBusSubtreeIntrospectFunc :: DBusSubtreeIntrospectFunc -> DBusSubtreeIntrospectFunc_WithClosures
drop_closures_DBusSubtreeIntrospectFunc DBusSubtreeIntrospectFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
node Ptr ()
_ = DBusSubtreeIntrospectFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
node

-- | Wrap the callback into a `GClosure`.
genClosure_DBusSubtreeIntrospectFunc :: MonadIO m => DBusSubtreeIntrospectFunc -> m (GClosure C_DBusSubtreeIntrospectFunc)
genClosure_DBusSubtreeIntrospectFunc :: forall (m :: * -> *).
MonadIO m =>
DBusSubtreeIntrospectFunc
-> m (GClosure C_DBusSubtreeIntrospectFunc)
genClosure_DBusSubtreeIntrospectFunc DBusSubtreeIntrospectFunc
cb = IO (GClosure C_DBusSubtreeIntrospectFunc)
-> m (GClosure C_DBusSubtreeIntrospectFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusSubtreeIntrospectFunc)
 -> m (GClosure C_DBusSubtreeIntrospectFunc))
-> IO (GClosure C_DBusSubtreeIntrospectFunc)
-> m (GClosure C_DBusSubtreeIntrospectFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusSubtreeIntrospectFunc_WithClosures
cb' = DBusSubtreeIntrospectFunc -> DBusSubtreeIntrospectFunc_WithClosures
drop_closures_DBusSubtreeIntrospectFunc DBusSubtreeIntrospectFunc
cb
    let cb'' :: C_DBusSubtreeIntrospectFunc
cb'' = Maybe (Ptr (FunPtr C_DBusSubtreeIntrospectFunc))
-> DBusSubtreeIntrospectFunc_WithClosures
-> C_DBusSubtreeIntrospectFunc
wrap_DBusSubtreeIntrospectFunc Maybe (Ptr (FunPtr C_DBusSubtreeIntrospectFunc))
forall a. Maybe a
Nothing DBusSubtreeIntrospectFunc_WithClosures
cb'
    C_DBusSubtreeIntrospectFunc
-> IO (FunPtr C_DBusSubtreeIntrospectFunc)
mk_DBusSubtreeIntrospectFunc C_DBusSubtreeIntrospectFunc
cb'' IO (FunPtr C_DBusSubtreeIntrospectFunc)
-> (FunPtr C_DBusSubtreeIntrospectFunc
    -> IO (GClosure C_DBusSubtreeIntrospectFunc))
-> IO (GClosure C_DBusSubtreeIntrospectFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusSubtreeIntrospectFunc
-> IO (GClosure C_DBusSubtreeIntrospectFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusSubtreeIntrospectFunc` into a `C_DBusSubtreeIntrospectFunc`.
wrap_DBusSubtreeIntrospectFunc :: 
    Maybe (Ptr (FunPtr C_DBusSubtreeIntrospectFunc)) ->
    DBusSubtreeIntrospectFunc_WithClosures ->
    C_DBusSubtreeIntrospectFunc
wrap_DBusSubtreeIntrospectFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeIntrospectFunc))
-> DBusSubtreeIntrospectFunc_WithClosures
-> C_DBusSubtreeIntrospectFunc
wrap_DBusSubtreeIntrospectFunc Maybe (Ptr (FunPtr C_DBusSubtreeIntrospectFunc))
gi'funptrptr DBusSubtreeIntrospectFunc_WithClosures
gi'cb Ptr DBusConnection
connection CString
sender CString
objectPath CString
node Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    sender' <- cstringToText sender
    objectPath' <- cstringToText objectPath
    node' <- cstringToText node
    result <- gi'cb  connection' sender' objectPath' node' userData
    maybeReleaseFunPtr gi'funptrptr
    maybeM FP.nullPtr result $ \[DBusInterfaceInfo]
result' -> do
        result'' <- (DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo))
-> [DBusInterfaceInfo] -> IO [Ptr DBusInterfaceInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed [DBusInterfaceInfo]
result'
        result''' <- packZeroTerminatedPtrArray result''
        return result'''


-- callback DBusSubtreeEnumerateFunc
{- Callable
  { returnType = Just (TCArray True (-1) (-1) (TBasicType TUTF8))
  , returnMayBeNull = False
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "A newly allocated array of strings for node names that are children of @object_path."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "sender"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The unique bus name of the remote caller."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The object path that was registered with g_dbus_connection_register_subtree()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The @user_data #gpointer passed to g_dbus_connection_register_subtree()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of the @enumerate function in #GDBusSubtreeVTable.\n\nThis function is called when generating introspection data and also\nwhen preparing to dispatch incoming messages in the event that the\n%G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not\nspecified (ie: to verify that the object path is valid).\n\nHierarchies are not supported; the items that you return should not\ncontain the `/` character.\n\nThe return value will be freed with g_strfreev()."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusSubtreeEnumerateFunc =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    Ptr () ->
    IO (Ptr CString)

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sender"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The unique bus name of the remote caller."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The object path that was registered with g_dbus_connection_register_subtree()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The @user_data #gpointer passed to g_dbus_connection_register_subtree()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusSubtreeEnumerateFunc :: FunPtr C_DBusSubtreeEnumerateFunc -> C_DBusSubtreeEnumerateFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusSubtreeEnumerateFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_DBusSubtreeEnumerateFunc
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> m [T.Text]
    -- ^ __Returns:__ A newly allocated array of strings for node names that are children of /@objectPath@/.
dynamic_DBusSubtreeEnumerateFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_DBusSubtreeEnumerateFunc
-> a -> Text -> Text -> Ptr () -> m [Text]
dynamic_DBusSubtreeEnumerateFunc FunPtr C_DBusSubtreeEnumerateFunc
__funPtr a
connection Text
sender Text
objectPath Ptr ()
userData = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    sender' <- textToCString sender
    objectPath' <- textToCString objectPath
    result <- (__dynamic_C_DBusSubtreeEnumerateFunc __funPtr) connection' sender' objectPath' userData
    checkUnexpectedReturnNULL "dBusSubtreeEnumerateFunc" result
    result' <- unpackZeroTerminatedUTF8CArray result
    mapZeroTerminatedCArray freeMem result
    freeMem result
    touchManagedPtr connection
    freeMem sender'
    freeMem objectPath'
    return result'

-- | Generate a function pointer callable from C code, from a `C_DBusSubtreeEnumerateFunc`.
foreign import ccall "wrapper"
    mk_DBusSubtreeEnumerateFunc :: C_DBusSubtreeEnumerateFunc -> IO (FunPtr C_DBusSubtreeEnumerateFunc)

-- | The type of the /@enumerate@/ function in t'GI.Gio.Structs.DBusSubtreeVTable.DBusSubtreeVTable'.
-- 
-- This function is called when generating introspection data and also
-- when preparing to dispatch incoming messages in the event that the
-- 'GI.Gio.Flags.DBusSubtreeFlagsDispatchToUnenumeratedNodes' flag is not
-- specified (ie: to verify that the object path is valid).
-- 
-- Hierarchies are not supported; the items that you return should not
-- contain the @\/@ character.
-- 
-- The return value will be freed with 'GI.GLib.Functions.strfreev'.
-- 
-- /Since: 2.26/
type DBusSubtreeEnumerateFunc =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> IO [T.Text]
    -- ^ __Returns:__ A newly allocated array of strings for node names that are children of /@objectPath@/.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSubtreeEnumerateFunc`@.
noDBusSubtreeEnumerateFunc :: Maybe DBusSubtreeEnumerateFunc
noDBusSubtreeEnumerateFunc :: Maybe DBusSubtreeEnumerateFunc
noDBusSubtreeEnumerateFunc = Maybe DBusSubtreeEnumerateFunc
forall a. Maybe a
Nothing

-- | The type of the /@enumerate@/ function in t'GI.Gio.Structs.DBusSubtreeVTable.DBusSubtreeVTable'.
-- 
-- This function is called when generating introspection data and also
-- when preparing to dispatch incoming messages in the event that the
-- 'GI.Gio.Flags.DBusSubtreeFlagsDispatchToUnenumeratedNodes' flag is not
-- specified (ie: to verify that the object path is valid).
-- 
-- Hierarchies are not supported; the items that you return should not
-- contain the @\/@ character.
-- 
-- The return value will be freed with 'GI.GLib.Functions.strfreev'.
-- 
-- /Since: 2.26/
type DBusSubtreeEnumerateFunc_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> IO [T.Text]
    -- ^ __Returns:__ A newly allocated array of strings for node names that are children of /@objectPath@/.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSubtreeEnumerateFunc_WithClosures`@.
noDBusSubtreeEnumerateFunc_WithClosures :: Maybe DBusSubtreeEnumerateFunc_WithClosures
noDBusSubtreeEnumerateFunc_WithClosures :: Maybe DBusSubtreeEnumerateFunc_WithClosures
noDBusSubtreeEnumerateFunc_WithClosures = Maybe DBusSubtreeEnumerateFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusSubtreeEnumerateFunc :: DBusSubtreeEnumerateFunc -> DBusSubtreeEnumerateFunc_WithClosures
drop_closures_DBusSubtreeEnumerateFunc :: DBusSubtreeEnumerateFunc -> DBusSubtreeEnumerateFunc_WithClosures
drop_closures_DBusSubtreeEnumerateFunc DBusSubtreeEnumerateFunc
_f DBusConnection
connection Text
sender Text
objectPath Ptr ()
_ = DBusSubtreeEnumerateFunc
_f DBusConnection
connection Text
sender Text
objectPath

-- | Wrap the callback into a `GClosure`.
genClosure_DBusSubtreeEnumerateFunc :: MonadIO m => DBusSubtreeEnumerateFunc -> m (GClosure C_DBusSubtreeEnumerateFunc)
genClosure_DBusSubtreeEnumerateFunc :: forall (m :: * -> *).
MonadIO m =>
DBusSubtreeEnumerateFunc -> m (GClosure C_DBusSubtreeEnumerateFunc)
genClosure_DBusSubtreeEnumerateFunc DBusSubtreeEnumerateFunc
cb = IO (GClosure C_DBusSubtreeEnumerateFunc)
-> m (GClosure C_DBusSubtreeEnumerateFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusSubtreeEnumerateFunc)
 -> m (GClosure C_DBusSubtreeEnumerateFunc))
-> IO (GClosure C_DBusSubtreeEnumerateFunc)
-> m (GClosure C_DBusSubtreeEnumerateFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusSubtreeEnumerateFunc_WithClosures
cb' = DBusSubtreeEnumerateFunc -> DBusSubtreeEnumerateFunc_WithClosures
drop_closures_DBusSubtreeEnumerateFunc DBusSubtreeEnumerateFunc
cb
    let cb'' :: C_DBusSubtreeEnumerateFunc
cb'' = Maybe (Ptr (FunPtr C_DBusSubtreeEnumerateFunc))
-> DBusSubtreeEnumerateFunc_WithClosures
-> C_DBusSubtreeEnumerateFunc
wrap_DBusSubtreeEnumerateFunc Maybe (Ptr (FunPtr C_DBusSubtreeEnumerateFunc))
forall a. Maybe a
Nothing DBusSubtreeEnumerateFunc_WithClosures
cb'
    C_DBusSubtreeEnumerateFunc
-> IO (FunPtr C_DBusSubtreeEnumerateFunc)
mk_DBusSubtreeEnumerateFunc C_DBusSubtreeEnumerateFunc
cb'' IO (FunPtr C_DBusSubtreeEnumerateFunc)
-> (FunPtr C_DBusSubtreeEnumerateFunc
    -> IO (GClosure C_DBusSubtreeEnumerateFunc))
-> IO (GClosure C_DBusSubtreeEnumerateFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusSubtreeEnumerateFunc
-> IO (GClosure C_DBusSubtreeEnumerateFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusSubtreeEnumerateFunc` into a `C_DBusSubtreeEnumerateFunc`.
wrap_DBusSubtreeEnumerateFunc :: 
    Maybe (Ptr (FunPtr C_DBusSubtreeEnumerateFunc)) ->
    DBusSubtreeEnumerateFunc_WithClosures ->
    C_DBusSubtreeEnumerateFunc
wrap_DBusSubtreeEnumerateFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeEnumerateFunc))
-> DBusSubtreeEnumerateFunc_WithClosures
-> C_DBusSubtreeEnumerateFunc
wrap_DBusSubtreeEnumerateFunc Maybe (Ptr (FunPtr C_DBusSubtreeEnumerateFunc))
gi'funptrptr DBusSubtreeEnumerateFunc_WithClosures
gi'cb Ptr DBusConnection
connection CString
sender CString
objectPath Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    sender' <- cstringToText sender
    objectPath' <- cstringToText objectPath
    result <- gi'cb  connection' sender' objectPath' userData
    maybeReleaseFunPtr gi'funptrptr
    result' <- packZeroTerminatedUTF8CArray result
    return result'


-- callback DBusSubtreeDispatchFunc
{- Callable
  { returnType =
      Just
        (TInterface
           Name { namespace = "Gio" , name = "DBusInterfaceVTable" })
  , returnMayBeNull = True
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "A #GDBusInterfaceVTable or %NULL if you don't want to handle the methods."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "sender"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The unique bus name of the remote caller."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The object path that was registered with g_dbus_connection_register_subtree()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "interface_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The D-Bus interface name that the method call or property access is for."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "node"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "out_user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "Return location for user data to pass to functions in the returned #GDBusInterfaceVTable."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The @user_data #gpointer passed to g_dbus_connection_register_subtree()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of the @dispatch function in #GDBusSubtreeVTable.\n\nSubtrees are flat.  @node, if non-%NULL, is always exactly one\nsegment of the object path (ie: it never contains a slash)."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusSubtreeDispatchFunc =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    CString ->
    CString ->
    Ptr () ->
    Ptr () ->
    IO (Ptr Gio.DBusInterfaceVTable.DBusInterfaceVTable)

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sender"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The unique bus name of the remote caller."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The object path that was registered with g_dbus_connection_register_subtree()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interface_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The D-Bus interface name that the method call or property access is for."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "node"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Return location for user data to pass to functions in the returned #GDBusInterfaceVTable."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The @user_data #gpointer passed to g_dbus_connection_register_subtree()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gio" , name = "DBusInterfaceVTable" })
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusSubtreeDispatchFunc :: FunPtr C_DBusSubtreeDispatchFunc -> C_DBusSubtreeDispatchFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusSubtreeDispatchFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_DBusSubtreeDispatchFunc
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name that the method call or property access is for.
    -> T.Text
    -- ^ /@node@/: A node that is a child of /@objectPath@/ (relative to /@objectPath@/) or 'P.Nothing' for the root of the subtree.
    -> Ptr ()
    -- ^ /@outUserData@/: Return location for user data to pass to functions in the returned t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> m (Maybe Gio.DBusInterfaceVTable.DBusInterfaceVTable)
    -- ^ __Returns:__ A t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable' or 'P.Nothing' if you don\'t want to handle the methods.
dynamic_DBusSubtreeDispatchFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_DBusSubtreeDispatchFunc
-> a
-> Text
-> Text
-> Text
-> Text
-> Ptr ()
-> Ptr ()
-> m (Maybe DBusInterfaceVTable)
dynamic_DBusSubtreeDispatchFunc FunPtr C_DBusSubtreeDispatchFunc
__funPtr a
connection Text
sender Text
objectPath Text
interfaceName Text
node Ptr ()
outUserData Ptr ()
userData = IO (Maybe DBusInterfaceVTable) -> m (Maybe DBusInterfaceVTable)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DBusInterfaceVTable) -> m (Maybe DBusInterfaceVTable))
-> IO (Maybe DBusInterfaceVTable) -> m (Maybe DBusInterfaceVTable)
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    sender' <- textToCString sender
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    node' <- textToCString node
    result <- (__dynamic_C_DBusSubtreeDispatchFunc __funPtr) connection' sender' objectPath' interfaceName' node' outUserData userData
    maybeResult <- convertIfNonNull result $ \Ptr DBusInterfaceVTable
result' -> do
        result'' <- ((ManagedPtr DBusInterfaceVTable -> DBusInterfaceVTable)
-> Ptr DBusInterfaceVTable -> IO DBusInterfaceVTable
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr DBusInterfaceVTable -> DBusInterfaceVTable
Gio.DBusInterfaceVTable.DBusInterfaceVTable) Ptr DBusInterfaceVTable
result'
        return result''
    touchManagedPtr connection
    freeMem sender'
    freeMem objectPath'
    freeMem interfaceName'
    freeMem node'
    return maybeResult

-- | Generate a function pointer callable from C code, from a `C_DBusSubtreeDispatchFunc`.
foreign import ccall "wrapper"
    mk_DBusSubtreeDispatchFunc :: C_DBusSubtreeDispatchFunc -> IO (FunPtr C_DBusSubtreeDispatchFunc)

-- | The type of the /@dispatch@/ function in t'GI.Gio.Structs.DBusSubtreeVTable.DBusSubtreeVTable'.
-- 
-- Subtrees are flat.  /@node@/, if non-'P.Nothing', is always exactly one
-- segment of the object path (ie: it never contains a slash).
-- 
-- /Since: 2.26/
type DBusSubtreeDispatchFunc =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name that the method call or property access is for.
    -> T.Text
    -- ^ /@node@/: A node that is a child of /@objectPath@/ (relative to /@objectPath@/) or 'P.Nothing' for the root of the subtree.
    -> Ptr ()
    -- ^ /@outUserData@/: Return location for user data to pass to functions in the returned t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
    -> IO (Maybe Gio.DBusInterfaceVTable.DBusInterfaceVTable)
    -- ^ __Returns:__ A t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable' or 'P.Nothing' if you don\'t want to handle the methods.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSubtreeDispatchFunc`@.
noDBusSubtreeDispatchFunc :: Maybe DBusSubtreeDispatchFunc
noDBusSubtreeDispatchFunc :: Maybe DBusSubtreeDispatchFunc
noDBusSubtreeDispatchFunc = Maybe DBusSubtreeDispatchFunc
forall a. Maybe a
Nothing

-- | The type of the /@dispatch@/ function in t'GI.Gio.Structs.DBusSubtreeVTable.DBusSubtreeVTable'.
-- 
-- Subtrees are flat.  /@node@/, if non-'P.Nothing', is always exactly one
-- segment of the object path (ie: it never contains a slash).
-- 
-- /Since: 2.26/
type DBusSubtreeDispatchFunc_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that was registered with 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name that the method call or property access is for.
    -> T.Text
    -- ^ /@node@/: A node that is a child of /@objectPath@/ (relative to /@objectPath@/) or 'P.Nothing' for the root of the subtree.
    -> Ptr ()
    -- ^ /@outUserData@/: Return location for user data to pass to functions in the returned t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree'.
    -> IO (Maybe Gio.DBusInterfaceVTable.DBusInterfaceVTable)
    -- ^ __Returns:__ A t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable' or 'P.Nothing' if you don\'t want to handle the methods.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSubtreeDispatchFunc_WithClosures`@.
noDBusSubtreeDispatchFunc_WithClosures :: Maybe DBusSubtreeDispatchFunc_WithClosures
noDBusSubtreeDispatchFunc_WithClosures :: Maybe DBusSubtreeDispatchFunc_WithClosures
noDBusSubtreeDispatchFunc_WithClosures = Maybe DBusSubtreeDispatchFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusSubtreeDispatchFunc :: DBusSubtreeDispatchFunc -> DBusSubtreeDispatchFunc_WithClosures
drop_closures_DBusSubtreeDispatchFunc :: DBusSubtreeDispatchFunc -> DBusSubtreeDispatchFunc_WithClosures
drop_closures_DBusSubtreeDispatchFunc DBusSubtreeDispatchFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
node Ptr ()
outUserData Ptr ()
_ = DBusSubtreeDispatchFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
node Ptr ()
outUserData

-- | Wrap the callback into a `GClosure`.
genClosure_DBusSubtreeDispatchFunc :: MonadIO m => DBusSubtreeDispatchFunc -> m (GClosure C_DBusSubtreeDispatchFunc)
genClosure_DBusSubtreeDispatchFunc :: forall (m :: * -> *).
MonadIO m =>
DBusSubtreeDispatchFunc -> m (GClosure C_DBusSubtreeDispatchFunc)
genClosure_DBusSubtreeDispatchFunc DBusSubtreeDispatchFunc
cb = IO (GClosure C_DBusSubtreeDispatchFunc)
-> m (GClosure C_DBusSubtreeDispatchFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusSubtreeDispatchFunc)
 -> m (GClosure C_DBusSubtreeDispatchFunc))
-> IO (GClosure C_DBusSubtreeDispatchFunc)
-> m (GClosure C_DBusSubtreeDispatchFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusSubtreeDispatchFunc_WithClosures
cb' = DBusSubtreeDispatchFunc -> DBusSubtreeDispatchFunc_WithClosures
drop_closures_DBusSubtreeDispatchFunc DBusSubtreeDispatchFunc
cb
    let cb'' :: C_DBusSubtreeDispatchFunc
cb'' = Maybe (Ptr (FunPtr C_DBusSubtreeDispatchFunc))
-> DBusSubtreeDispatchFunc_WithClosures
-> C_DBusSubtreeDispatchFunc
wrap_DBusSubtreeDispatchFunc Maybe (Ptr (FunPtr C_DBusSubtreeDispatchFunc))
forall a. Maybe a
Nothing DBusSubtreeDispatchFunc_WithClosures
cb'
    C_DBusSubtreeDispatchFunc -> IO (FunPtr C_DBusSubtreeDispatchFunc)
mk_DBusSubtreeDispatchFunc C_DBusSubtreeDispatchFunc
cb'' IO (FunPtr C_DBusSubtreeDispatchFunc)
-> (FunPtr C_DBusSubtreeDispatchFunc
    -> IO (GClosure C_DBusSubtreeDispatchFunc))
-> IO (GClosure C_DBusSubtreeDispatchFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusSubtreeDispatchFunc
-> IO (GClosure C_DBusSubtreeDispatchFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusSubtreeDispatchFunc` into a `C_DBusSubtreeDispatchFunc`.
wrap_DBusSubtreeDispatchFunc :: 
    Maybe (Ptr (FunPtr C_DBusSubtreeDispatchFunc)) ->
    DBusSubtreeDispatchFunc_WithClosures ->
    C_DBusSubtreeDispatchFunc
wrap_DBusSubtreeDispatchFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeDispatchFunc))
-> DBusSubtreeDispatchFunc_WithClosures
-> C_DBusSubtreeDispatchFunc
wrap_DBusSubtreeDispatchFunc Maybe (Ptr (FunPtr C_DBusSubtreeDispatchFunc))
gi'funptrptr DBusSubtreeDispatchFunc_WithClosures
gi'cb Ptr DBusConnection
connection CString
sender CString
objectPath CString
interfaceName CString
node Ptr ()
outUserData Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    sender' <- cstringToText sender
    objectPath' <- cstringToText objectPath
    interfaceName' <- cstringToText interfaceName
    node' <- cstringToText node
    result <- gi'cb  connection' sender' objectPath' interfaceName' node' outUserData userData
    maybeReleaseFunPtr gi'funptrptr
    maybeM FP.nullPtr result $ \DBusInterfaceVTable
result' -> do
        result'' <- DBusInterfaceVTable -> IO (Ptr DBusInterfaceVTable)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceVTable
result'
        return result''


-- callback DBusSignalCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "sender_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The unique bus name of the sender of the signal,\n   or %NULL on a peer-to-peer D-Bus connection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "The object path that the signal was emitted on."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "interface_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name of the interface."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "signal_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name of the signal."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "parameters"
          , argType = TVariant
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "A #GVariant tuple with parameters for the signal."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "User data passed when subscribing to the signal."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Signature for callback function used in g_dbus_connection_signal_subscribe()."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusSignalCallback =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    CString ->
    CString ->
    Ptr GVariant ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sender_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The unique bus name of the sender of the signal,\n   or %NULL on a peer-to-peer D-Bus connection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The object path that the signal was emitted on."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interface_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the interface."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signal_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parameters"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A #GVariant tuple with parameters for the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "User data passed when subscribing to the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusSignalCallback :: FunPtr C_DBusSignalCallback -> C_DBusSignalCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusSignalCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_DBusSignalCallback
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Maybe (T.Text)
    -- ^ /@senderName@/: The unique bus name of the sender of the signal,
    --    or 'P.Nothing' on a peer-to-peer D-Bus connection.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the signal was emitted on.
    -> T.Text
    -- ^ /@interfaceName@/: The name of the interface.
    -> T.Text
    -- ^ /@signalName@/: The name of the signal.
    -> GVariant
    -- ^ /@parameters@/: A t'GVariant' tuple with parameters for the signal.
    -> Ptr ()
    -- ^ /@userData@/: User data passed when subscribing to the signal.
    -> m ()
dynamic_DBusSignalCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_DBusSignalCallback
-> a
-> Maybe Text
-> Text
-> Text
-> Text
-> GVariant
-> Ptr ()
-> m ()
dynamic_DBusSignalCallback FunPtr C_DBusSignalCallback
__funPtr a
connection Maybe Text
senderName Text
objectPath Text
interfaceName Text
signalName GVariant
parameters Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    maybeSenderName <- case senderName of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jSenderName -> do
            jSenderName' <- Text -> IO CString
textToCString Text
jSenderName
            return jSenderName'
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    signalName' <- textToCString signalName
    parameters' <- unsafeManagedPtrGetPtr parameters
    (__dynamic_C_DBusSignalCallback __funPtr) connection' maybeSenderName objectPath' interfaceName' signalName' parameters' userData
    touchManagedPtr connection
    touchManagedPtr parameters
    freeMem maybeSenderName
    freeMem objectPath'
    freeMem interfaceName'
    freeMem signalName'
    return ()

-- | Generate a function pointer callable from C code, from a `C_DBusSignalCallback`.
foreign import ccall "wrapper"
    mk_DBusSignalCallback :: C_DBusSignalCallback -> IO (FunPtr C_DBusSignalCallback)

-- | Signature for callback function used in 'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe'.
-- 
-- /Since: 2.26/
type DBusSignalCallback =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Maybe T.Text
    -- ^ /@senderName@/: The unique bus name of the sender of the signal,
    --    or 'P.Nothing' on a peer-to-peer D-Bus connection.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the signal was emitted on.
    -> T.Text
    -- ^ /@interfaceName@/: The name of the interface.
    -> T.Text
    -- ^ /@signalName@/: The name of the signal.
    -> GVariant
    -- ^ /@parameters@/: A t'GVariant' tuple with parameters for the signal.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSignalCallback`@.
noDBusSignalCallback :: Maybe DBusSignalCallback
noDBusSignalCallback :: Maybe DBusSignalCallback
noDBusSignalCallback = Maybe DBusSignalCallback
forall a. Maybe a
Nothing

-- | Signature for callback function used in 'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe'.
-- 
-- /Since: 2.26/
type DBusSignalCallback_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Maybe T.Text
    -- ^ /@senderName@/: The unique bus name of the sender of the signal,
    --    or 'P.Nothing' on a peer-to-peer D-Bus connection.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the signal was emitted on.
    -> T.Text
    -- ^ /@interfaceName@/: The name of the interface.
    -> T.Text
    -- ^ /@signalName@/: The name of the signal.
    -> GVariant
    -- ^ /@parameters@/: A t'GVariant' tuple with parameters for the signal.
    -> Ptr ()
    -- ^ /@userData@/: User data passed when subscribing to the signal.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusSignalCallback_WithClosures`@.
noDBusSignalCallback_WithClosures :: Maybe DBusSignalCallback_WithClosures
noDBusSignalCallback_WithClosures :: Maybe DBusSignalCallback_WithClosures
noDBusSignalCallback_WithClosures = Maybe DBusSignalCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusSignalCallback :: DBusSignalCallback -> DBusSignalCallback_WithClosures
drop_closures_DBusSignalCallback :: DBusSignalCallback -> DBusSignalCallback_WithClosures
drop_closures_DBusSignalCallback DBusSignalCallback
_f DBusConnection
connection Maybe Text
senderName Text
objectPath Text
interfaceName Text
signalName GVariant
parameters Ptr ()
_ = DBusSignalCallback
_f DBusConnection
connection Maybe Text
senderName Text
objectPath Text
interfaceName Text
signalName GVariant
parameters

-- | Wrap the callback into a `GClosure`.
genClosure_DBusSignalCallback :: MonadIO m => DBusSignalCallback -> m (GClosure C_DBusSignalCallback)
genClosure_DBusSignalCallback :: forall (m :: * -> *).
MonadIO m =>
DBusSignalCallback -> m (GClosure C_DBusSignalCallback)
genClosure_DBusSignalCallback DBusSignalCallback
cb = IO (GClosure C_DBusSignalCallback)
-> m (GClosure C_DBusSignalCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusSignalCallback)
 -> m (GClosure C_DBusSignalCallback))
-> IO (GClosure C_DBusSignalCallback)
-> m (GClosure C_DBusSignalCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusSignalCallback_WithClosures
cb' = DBusSignalCallback -> DBusSignalCallback_WithClosures
drop_closures_DBusSignalCallback DBusSignalCallback
cb
    let cb'' :: C_DBusSignalCallback
cb'' = Maybe (Ptr (FunPtr C_DBusSignalCallback))
-> DBusSignalCallback_WithClosures -> C_DBusSignalCallback
wrap_DBusSignalCallback Maybe (Ptr (FunPtr C_DBusSignalCallback))
forall a. Maybe a
Nothing DBusSignalCallback_WithClosures
cb'
    C_DBusSignalCallback -> IO (FunPtr C_DBusSignalCallback)
mk_DBusSignalCallback C_DBusSignalCallback
cb'' IO (FunPtr C_DBusSignalCallback)
-> (FunPtr C_DBusSignalCallback
    -> IO (GClosure C_DBusSignalCallback))
-> IO (GClosure C_DBusSignalCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusSignalCallback -> IO (GClosure C_DBusSignalCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusSignalCallback` into a `C_DBusSignalCallback`.
wrap_DBusSignalCallback :: 
    Maybe (Ptr (FunPtr C_DBusSignalCallback)) ->
    DBusSignalCallback_WithClosures ->
    C_DBusSignalCallback
wrap_DBusSignalCallback :: Maybe (Ptr (FunPtr C_DBusSignalCallback))
-> DBusSignalCallback_WithClosures -> C_DBusSignalCallback
wrap_DBusSignalCallback Maybe (Ptr (FunPtr C_DBusSignalCallback))
gi'funptrptr DBusSignalCallback_WithClosures
gi'cb Ptr DBusConnection
connection CString
senderName CString
objectPath CString
interfaceName CString
signalName Ptr GVariant
parameters Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    maybeSenderName <-
        if senderName == FP.nullPtr
        then return Nothing
        else do
            senderName' <- cstringToText senderName
            return $ Just senderName'
    objectPath' <- cstringToText objectPath
    interfaceName' <- cstringToText interfaceName
    signalName' <- cstringToText signalName
    parameters' <- B.GVariant.newGVariantFromPtr parameters
    gi'cb  connection' maybeSenderName objectPath' interfaceName' signalName' parameters' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback DBusProxyTypeFunc
{- Callable
  { returnType = Just (TBasicType TGType)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "A #GType to use for the remote object. The returned type\n  must be a #GDBusProxy or #GDBusObjectProxy -derived\n  type."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "manager"
          , argType =
              TInterface
                Name { namespace = "Gio" , name = "DBusObjectManagerClient" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusObjectManagerClient."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The object path of the remote object."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "interface_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "data passed in by the user."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Function signature for a function used to determine the #GType to\nuse for an interface proxy (if @interface_name is not %NULL) or\nobject proxy (if @interface_name is %NULL).\n\nThis function is called in the\n[thread-default main loop][g-main-context-push-thread-default]\nthat @manager was constructed in."
        , sinceVersion = Just "2.30"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusProxyTypeFunc =
    Ptr Gio.DBusObjectManagerClient.DBusObjectManagerClient ->
    CString ->
    CString ->
    Ptr () ->
    IO CGType

-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "Gio" , name = "DBusObjectManagerClient" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusObjectManagerClient."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The object path of the remote object."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interface_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data passed in by the user."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusProxyTypeFunc :: FunPtr C_DBusProxyTypeFunc -> C_DBusProxyTypeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusProxyTypeFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusObjectManagerClient.IsDBusObjectManagerClient a) =>
    FunPtr C_DBusProxyTypeFunc
    -> a
    -- ^ /@manager@/: A t'GI.Gio.Objects.DBusObjectManagerClient.DBusObjectManagerClient'.
    -> T.Text
    -- ^ /@objectPath@/: The object path of the remote object.
    -> Maybe (T.Text)
    -- ^ /@interfaceName@/: The interface name of the remote object or 'P.Nothing' if a t'GI.Gio.Objects.DBusObjectProxy.DBusObjectProxy' t'GType' is requested.
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> m GType
    -- ^ __Returns:__ A t'GType' to use for the remote object. The returned type
    --   must be a t'GI.Gio.Objects.DBusProxy.DBusProxy' or t'GI.Gio.Objects.DBusObjectProxy.DBusObjectProxy' -derived
    --   type.
dynamic_DBusProxyTypeFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusObjectManagerClient a) =>
FunPtr C_DBusProxyTypeFunc
-> a -> Text -> Maybe Text -> Ptr () -> m GType
dynamic_DBusProxyTypeFunc FunPtr C_DBusProxyTypeFunc
__funPtr a
manager Text
objectPath Maybe Text
interfaceName Ptr ()
data_ = IO GType -> m GType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
    manager' <- a -> IO (Ptr DBusObjectManagerClient)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    objectPath' <- textToCString objectPath
    maybeInterfaceName <- case interfaceName of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jInterfaceName -> do
            jInterfaceName' <- Text -> IO CString
textToCString Text
jInterfaceName
            return jInterfaceName'
    result <- (__dynamic_C_DBusProxyTypeFunc __funPtr) manager' objectPath' maybeInterfaceName data_
    let result' = Word64 -> GType
GType Word64
result
    touchManagedPtr manager
    freeMem objectPath'
    freeMem maybeInterfaceName
    return result'

-- | Generate a function pointer callable from C code, from a `C_DBusProxyTypeFunc`.
foreign import ccall "wrapper"
    mk_DBusProxyTypeFunc :: C_DBusProxyTypeFunc -> IO (FunPtr C_DBusProxyTypeFunc)

-- | Function signature for a function used to determine the t'GType' to
-- use for an interface proxy (if /@interfaceName@/ is not 'P.Nothing') or
-- object proxy (if /@interfaceName@/ is 'P.Nothing').
-- 
-- This function is called in the
-- [thread-default main loop][g-main-context-push-thread-default]
-- that /@manager@/ was constructed in.
-- 
-- /Since: 2.30/
type DBusProxyTypeFunc =
    Gio.DBusObjectManagerClient.DBusObjectManagerClient
    -- ^ /@manager@/: A t'GI.Gio.Objects.DBusObjectManagerClient.DBusObjectManagerClient'.
    -> T.Text
    -- ^ /@objectPath@/: The object path of the remote object.
    -> Maybe T.Text
    -- ^ /@interfaceName@/: The interface name of the remote object or 'P.Nothing' if a t'GI.Gio.Objects.DBusObjectProxy.DBusObjectProxy' t'GType' is requested.
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> IO GType
    -- ^ __Returns:__ A t'GType' to use for the remote object. The returned type
    --   must be a t'GI.Gio.Objects.DBusProxy.DBusProxy' or t'GI.Gio.Objects.DBusObjectProxy.DBusObjectProxy' -derived
    --   type.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusProxyTypeFunc`@.
noDBusProxyTypeFunc :: Maybe DBusProxyTypeFunc
noDBusProxyTypeFunc :: Maybe DBusProxyTypeFunc
noDBusProxyTypeFunc = Maybe DBusProxyTypeFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_DBusProxyTypeFunc :: MonadIO m => DBusProxyTypeFunc -> m (GClosure C_DBusProxyTypeFunc)
genClosure_DBusProxyTypeFunc :: forall (m :: * -> *).
MonadIO m =>
DBusProxyTypeFunc -> m (GClosure C_DBusProxyTypeFunc)
genClosure_DBusProxyTypeFunc DBusProxyTypeFunc
cb = IO (GClosure C_DBusProxyTypeFunc)
-> m (GClosure C_DBusProxyTypeFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusProxyTypeFunc)
 -> m (GClosure C_DBusProxyTypeFunc))
-> IO (GClosure C_DBusProxyTypeFunc)
-> m (GClosure C_DBusProxyTypeFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_DBusProxyTypeFunc
cb' = Maybe (Ptr (FunPtr C_DBusProxyTypeFunc))
-> DBusProxyTypeFunc -> C_DBusProxyTypeFunc
wrap_DBusProxyTypeFunc Maybe (Ptr (FunPtr C_DBusProxyTypeFunc))
forall a. Maybe a
Nothing DBusProxyTypeFunc
cb
    C_DBusProxyTypeFunc -> IO (FunPtr C_DBusProxyTypeFunc)
mk_DBusProxyTypeFunc C_DBusProxyTypeFunc
cb' IO (FunPtr C_DBusProxyTypeFunc)
-> (FunPtr C_DBusProxyTypeFunc
    -> IO (GClosure C_DBusProxyTypeFunc))
-> IO (GClosure C_DBusProxyTypeFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusProxyTypeFunc -> IO (GClosure C_DBusProxyTypeFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusProxyTypeFunc` into a `C_DBusProxyTypeFunc`.
wrap_DBusProxyTypeFunc :: 
    Maybe (Ptr (FunPtr C_DBusProxyTypeFunc)) ->
    DBusProxyTypeFunc ->
    C_DBusProxyTypeFunc
wrap_DBusProxyTypeFunc :: Maybe (Ptr (FunPtr C_DBusProxyTypeFunc))
-> DBusProxyTypeFunc -> C_DBusProxyTypeFunc
wrap_DBusProxyTypeFunc Maybe (Ptr (FunPtr C_DBusProxyTypeFunc))
gi'funptrptr DBusProxyTypeFunc
gi'cb Ptr DBusObjectManagerClient
manager CString
objectPath CString
interfaceName Ptr ()
data_ = do
    manager' <- ((ManagedPtr DBusObjectManagerClient -> DBusObjectManagerClient)
-> Ptr DBusObjectManagerClient -> IO DBusObjectManagerClient
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusObjectManagerClient -> DBusObjectManagerClient
Gio.DBusObjectManagerClient.DBusObjectManagerClient) Ptr DBusObjectManagerClient
manager
    objectPath' <- cstringToText objectPath
    maybeInterfaceName <-
        if interfaceName == FP.nullPtr
        then return Nothing
        else do
            interfaceName' <- cstringToText interfaceName
            return $ Just interfaceName'
    result <- gi'cb  manager' objectPath' maybeInterfaceName data_
    maybeReleaseFunPtr gi'funptrptr
    let result' = GType -> Word64
gtypeToCGType GType
result
    return result'


-- callback DBusMessageFilterFunction
{- Callable
  { returnType =
      Just (TInterface Name { namespace = "Gio" , name = "DBusMessage" })
  , returnMayBeNull = True
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "A #GDBusMessage that will be freed with\ng_object_unref() or %NULL to drop the message. Passive filter\nfunctions can simply return the passed @message object."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "message"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusMessage" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "A locked #GDBusMessage that the filter function takes ownership of."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferEverything
          }
      , Arg
          { argCName = "incoming"
          , argType = TBasicType TBoolean
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "%TRUE if it is a message received from the other peer, %FALSE if it is\na message to be sent to the other peer."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "User data passed when adding the filter."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Signature for function used in g_dbus_connection_add_filter().\n\nA filter function is passed a #GDBusMessage and expected to return\na #GDBusMessage too. Passive filter functions that don't modify the\nmessage can simply return the @message object:\n|[\nstatic GDBusMessage *\npassive_filter (GDBusConnection *connection\n                GDBusMessage    *message,\n                gboolean         incoming,\n                gpointer         user_data)\n{\n  // inspect @message\n  return message;\n}\n]|\nFilter functions that wants to drop a message can simply return %NULL:\n|[\nstatic GDBusMessage *\ndrop_filter (GDBusConnection *connection\n             GDBusMessage    *message,\n             gboolean         incoming,\n             gpointer         user_data)\n{\n  if (should_drop_message)\n    {\n      g_object_unref (message);\n      message = NULL;\n    }\n  return message;\n}\n]|\nFinally, a filter function may modify a message by copying it:\n|[\nstatic GDBusMessage *\nmodifying_filter (GDBusConnection *connection\n                  GDBusMessage    *message,\n                  gboolean         incoming,\n                  gpointer         user_data)\n{\n  GDBusMessage *copy;\n  GError *error;\n\n  error = NULL;\n  copy = g_dbus_message_copy (message, &error);\n  // handle @error being set\n  g_object_unref (message);\n\n  // modify @copy\n\n  return copy;\n}\n]|\nIf the returned #GDBusMessage is different from @message and cannot\nbe sent on @connection (it could use features, such as file\ndescriptors, not compatible with @connection), then a warning is\nlogged to standard error. Applications can\ncheck this ahead of time using g_dbus_message_to_blob() passing a\n#GDBusCapabilityFlags value obtained from @connection."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusMessageFilterFunction =
    Ptr Gio.DBusConnection.DBusConnection ->
    Ptr Gio.DBusMessage.DBusMessage ->
    CInt ->
    Ptr () ->
    IO (Ptr Gio.DBusMessage.DBusMessage)

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "message"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A locked #GDBusMessage that the filter function takes ownership of."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "incoming"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE if it is a message received from the other peer, %FALSE if it is\na message to be sent to the other peer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data passed when adding the filter."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "DBusMessage" })
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusMessageFilterFunction :: FunPtr C_DBusMessageFilterFunction -> C_DBusMessageFilterFunction

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusMessageFilterFunction ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a, Gio.DBusMessage.IsDBusMessage b) =>
    FunPtr C_DBusMessageFilterFunction
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> b
    -- ^ /@message@/: A locked t'GI.Gio.Objects.DBusMessage.DBusMessage' that the filter function takes ownership of.
    -> Bool
    -- ^ /@incoming@/: 'P.True' if it is a message received from the other peer, 'P.False' if it is
    -- a message to be sent to the other peer.
    -> Ptr ()
    -- ^ /@userData@/: User data passed when adding the filter.
    -> m (Maybe Gio.DBusMessage.DBusMessage)
    -- ^ __Returns:__ A t'GI.Gio.Objects.DBusMessage.DBusMessage' that will be freed with
    -- 'GI.GObject.Objects.Object.objectUnref' or 'P.Nothing' to drop the message. Passive filter
    -- functions can simply return the passed /@message@/ object.
dynamic_DBusMessageFilterFunction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusConnection a, IsDBusMessage b) =>
FunPtr C_DBusMessageFilterFunction
-> a -> b -> Bool -> Ptr () -> m (Maybe DBusMessage)
dynamic_DBusMessageFilterFunction FunPtr C_DBusMessageFilterFunction
__funPtr a
connection b
message Bool
incoming Ptr ()
userData = IO (Maybe DBusMessage) -> m (Maybe DBusMessage)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DBusMessage) -> m (Maybe DBusMessage))
-> IO (Maybe DBusMessage) -> m (Maybe DBusMessage)
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    message' <- B.ManagedPtr.disownObject message
    let incoming' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
incoming
    result <- (__dynamic_C_DBusMessageFilterFunction __funPtr) connection' message' incoming' userData
    maybeResult <- convertIfNonNull result $ \Ptr DBusMessage
result' -> do
        result'' <- ((ManagedPtr DBusMessage -> DBusMessage)
-> Ptr DBusMessage -> IO DBusMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusMessage -> DBusMessage
Gio.DBusMessage.DBusMessage) Ptr DBusMessage
result'
        return result''
    touchManagedPtr connection
    touchManagedPtr message
    return maybeResult

-- | Generate a function pointer callable from C code, from a `C_DBusMessageFilterFunction`.
foreign import ccall "wrapper"
    mk_DBusMessageFilterFunction :: C_DBusMessageFilterFunction -> IO (FunPtr C_DBusMessageFilterFunction)

-- | Signature for function used in 'GI.Gio.Objects.DBusConnection.dBusConnectionAddFilter'.
-- 
-- A filter function is passed a t'GI.Gio.Objects.DBusMessage.DBusMessage' and expected to return
-- a t'GI.Gio.Objects.DBusMessage.DBusMessage' too. Passive filter functions that don\'t modify the
-- message can simply return the /@message@/ object:
-- >
-- >static GDBusMessage *
-- >passive_filter (GDBusConnection *connection
-- >                GDBusMessage    *message,
-- >                gboolean         incoming,
-- >                gpointer         user_data)
-- >{
-- >  // inspect @message
-- >  return message;
-- >}
-- 
-- Filter functions that wants to drop a message can simply return 'P.Nothing':
-- >
-- >static GDBusMessage *
-- >drop_filter (GDBusConnection *connection
-- >             GDBusMessage    *message,
-- >             gboolean         incoming,
-- >             gpointer         user_data)
-- >{
-- >  if (should_drop_message)
-- >    {
-- >      g_object_unref (message);
-- >      message = NULL;
-- >    }
-- >  return message;
-- >}
-- 
-- Finally, a filter function may modify a message by copying it:
-- >
-- >static GDBusMessage *
-- >modifying_filter (GDBusConnection *connection
-- >                  GDBusMessage    *message,
-- >                  gboolean         incoming,
-- >                  gpointer         user_data)
-- >{
-- >  GDBusMessage *copy;
-- >  GError *error;
-- >
-- >  error = NULL;
-- >  copy = g_dbus_message_copy (message, &error);
-- >  // handle @error being set
-- >  g_object_unref (message);
-- >
-- >  // modify @copy
-- >
-- >  return copy;
-- >}
-- 
-- If the returned t'GI.Gio.Objects.DBusMessage.DBusMessage' is different from /@message@/ and cannot
-- be sent on /@connection@/ (it could use features, such as file
-- descriptors, not compatible with /@connection@/), then a warning is
-- logged to standard error. Applications can
-- check this ahead of time using 'GI.Gio.Objects.DBusMessage.dBusMessageToBlob' passing a
-- t'GI.Gio.Flags.DBusCapabilityFlags' value obtained from /@connection@/.
-- 
-- /Since: 2.26/
type DBusMessageFilterFunction =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Gio.DBusMessage.DBusMessage
    -- ^ /@message@/: A locked t'GI.Gio.Objects.DBusMessage.DBusMessage' that the filter function takes ownership of.
    -> Bool
    -- ^ /@incoming@/: 'P.True' if it is a message received from the other peer, 'P.False' if it is
    -- a message to be sent to the other peer.
    -> IO (Maybe Gio.DBusMessage.DBusMessage)
    -- ^ __Returns:__ A t'GI.Gio.Objects.DBusMessage.DBusMessage' that will be freed with
    -- 'GI.GObject.Objects.Object.objectUnref' or 'P.Nothing' to drop the message. Passive filter
    -- functions can simply return the passed /@message@/ object.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusMessageFilterFunction`@.
noDBusMessageFilterFunction :: Maybe DBusMessageFilterFunction
noDBusMessageFilterFunction :: Maybe DBusMessageFilterFunction
noDBusMessageFilterFunction = Maybe DBusMessageFilterFunction
forall a. Maybe a
Nothing

-- | Signature for function used in 'GI.Gio.Objects.DBusConnection.dBusConnectionAddFilter'.
-- 
-- A filter function is passed a t'GI.Gio.Objects.DBusMessage.DBusMessage' and expected to return
-- a t'GI.Gio.Objects.DBusMessage.DBusMessage' too. Passive filter functions that don\'t modify the
-- message can simply return the /@message@/ object:
-- >
-- >static GDBusMessage *
-- >passive_filter (GDBusConnection *connection
-- >                GDBusMessage    *message,
-- >                gboolean         incoming,
-- >                gpointer         user_data)
-- >{
-- >  // inspect @message
-- >  return message;
-- >}
-- 
-- Filter functions that wants to drop a message can simply return 'P.Nothing':
-- >
-- >static GDBusMessage *
-- >drop_filter (GDBusConnection *connection
-- >             GDBusMessage    *message,
-- >             gboolean         incoming,
-- >             gpointer         user_data)
-- >{
-- >  if (should_drop_message)
-- >    {
-- >      g_object_unref (message);
-- >      message = NULL;
-- >    }
-- >  return message;
-- >}
-- 
-- Finally, a filter function may modify a message by copying it:
-- >
-- >static GDBusMessage *
-- >modifying_filter (GDBusConnection *connection
-- >                  GDBusMessage    *message,
-- >                  gboolean         incoming,
-- >                  gpointer         user_data)
-- >{
-- >  GDBusMessage *copy;
-- >  GError *error;
-- >
-- >  error = NULL;
-- >  copy = g_dbus_message_copy (message, &error);
-- >  // handle @error being set
-- >  g_object_unref (message);
-- >
-- >  // modify @copy
-- >
-- >  return copy;
-- >}
-- 
-- If the returned t'GI.Gio.Objects.DBusMessage.DBusMessage' is different from /@message@/ and cannot
-- be sent on /@connection@/ (it could use features, such as file
-- descriptors, not compatible with /@connection@/), then a warning is
-- logged to standard error. Applications can
-- check this ahead of time using 'GI.Gio.Objects.DBusMessage.dBusMessageToBlob' passing a
-- t'GI.Gio.Flags.DBusCapabilityFlags' value obtained from /@connection@/.
-- 
-- /Since: 2.26/
type DBusMessageFilterFunction_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Gio.DBusMessage.DBusMessage
    -- ^ /@message@/: A locked t'GI.Gio.Objects.DBusMessage.DBusMessage' that the filter function takes ownership of.
    -> Bool
    -- ^ /@incoming@/: 'P.True' if it is a message received from the other peer, 'P.False' if it is
    -- a message to be sent to the other peer.
    -> Ptr ()
    -- ^ /@userData@/: User data passed when adding the filter.
    -> IO (Maybe Gio.DBusMessage.DBusMessage)
    -- ^ __Returns:__ A t'GI.Gio.Objects.DBusMessage.DBusMessage' that will be freed with
    -- 'GI.GObject.Objects.Object.objectUnref' or 'P.Nothing' to drop the message. Passive filter
    -- functions can simply return the passed /@message@/ object.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusMessageFilterFunction_WithClosures`@.
noDBusMessageFilterFunction_WithClosures :: Maybe DBusMessageFilterFunction_WithClosures
noDBusMessageFilterFunction_WithClosures :: Maybe DBusMessageFilterFunction_WithClosures
noDBusMessageFilterFunction_WithClosures = Maybe DBusMessageFilterFunction_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusMessageFilterFunction :: DBusMessageFilterFunction -> DBusMessageFilterFunction_WithClosures
drop_closures_DBusMessageFilterFunction :: DBusMessageFilterFunction -> DBusMessageFilterFunction_WithClosures
drop_closures_DBusMessageFilterFunction DBusMessageFilterFunction
_f DBusConnection
connection DBusMessage
message Bool
incoming Ptr ()
_ = DBusMessageFilterFunction
_f DBusConnection
connection DBusMessage
message Bool
incoming

-- | Wrap the callback into a `GClosure`.
genClosure_DBusMessageFilterFunction :: MonadIO m => DBusMessageFilterFunction -> m (GClosure C_DBusMessageFilterFunction)
genClosure_DBusMessageFilterFunction :: forall (m :: * -> *).
MonadIO m =>
DBusMessageFilterFunction
-> m (GClosure C_DBusMessageFilterFunction)
genClosure_DBusMessageFilterFunction DBusMessageFilterFunction
cb = IO (GClosure C_DBusMessageFilterFunction)
-> m (GClosure C_DBusMessageFilterFunction)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusMessageFilterFunction)
 -> m (GClosure C_DBusMessageFilterFunction))
-> IO (GClosure C_DBusMessageFilterFunction)
-> m (GClosure C_DBusMessageFilterFunction)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusMessageFilterFunction_WithClosures
cb' = DBusMessageFilterFunction -> DBusMessageFilterFunction_WithClosures
drop_closures_DBusMessageFilterFunction DBusMessageFilterFunction
cb
    let cb'' :: C_DBusMessageFilterFunction
cb'' = Maybe (Ptr (FunPtr C_DBusMessageFilterFunction))
-> DBusMessageFilterFunction_WithClosures
-> C_DBusMessageFilterFunction
wrap_DBusMessageFilterFunction Maybe (Ptr (FunPtr C_DBusMessageFilterFunction))
forall a. Maybe a
Nothing DBusMessageFilterFunction_WithClosures
cb'
    C_DBusMessageFilterFunction
-> IO (FunPtr C_DBusMessageFilterFunction)
mk_DBusMessageFilterFunction C_DBusMessageFilterFunction
cb'' IO (FunPtr C_DBusMessageFilterFunction)
-> (FunPtr C_DBusMessageFilterFunction
    -> IO (GClosure C_DBusMessageFilterFunction))
-> IO (GClosure C_DBusMessageFilterFunction)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusMessageFilterFunction
-> IO (GClosure C_DBusMessageFilterFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusMessageFilterFunction` into a `C_DBusMessageFilterFunction`.
wrap_DBusMessageFilterFunction :: 
    Maybe (Ptr (FunPtr C_DBusMessageFilterFunction)) ->
    DBusMessageFilterFunction_WithClosures ->
    C_DBusMessageFilterFunction
wrap_DBusMessageFilterFunction :: Maybe (Ptr (FunPtr C_DBusMessageFilterFunction))
-> DBusMessageFilterFunction_WithClosures
-> C_DBusMessageFilterFunction
wrap_DBusMessageFilterFunction Maybe (Ptr (FunPtr C_DBusMessageFilterFunction))
gi'funptrptr DBusMessageFilterFunction_WithClosures
gi'cb Ptr DBusConnection
connection Ptr DBusMessage
message CInt
incoming Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    message' <- (wrapObject Gio.DBusMessage.DBusMessage) message
    let incoming' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
incoming
    result <- gi'cb  connection' message' incoming' userData
    maybeReleaseFunPtr gi'funptrptr
    maybeM FP.nullPtr result $ \DBusMessage
result' -> do
        result'' <- DBusMessage -> IO (Ptr DBusMessage)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject DBusMessage
result'
        return result''


-- callback DBusInterfaceSetPropertyFunc
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "%TRUE if the property was set to @value, %FALSE if @error is set."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "sender"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The unique bus name of the remote caller."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "The object path that the method was invoked on."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "interface_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The D-Bus interface name for the property."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "property_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name of the property to get the value of."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "value"
          , argType = TVariant
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The value to set the property to."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "error"
          , argType = TError
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "Return location for error."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The @user_data #gpointer passed to g_dbus_connection_register_object()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of the @set_property function in #GDBusInterfaceVTable."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusInterfaceSetPropertyFunc =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    CString ->
    CString ->
    Ptr GVariant ->
    Ptr GError ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sender"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The unique bus name of the remote caller."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The object path that the method was invoked on."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interface_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The D-Bus interface name for the property."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the property to get the value of."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The value to set the property to."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "error"
--           , argType = TError
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Return location for error."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The @user_data #gpointer passed to g_dbus_connection_register_object()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusInterfaceSetPropertyFunc :: FunPtr C_DBusInterfaceSetPropertyFunc -> C_DBusInterfaceSetPropertyFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusInterfaceSetPropertyFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_DBusInterfaceSetPropertyFunc
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name for the property.
    -> T.Text
    -- ^ /@propertyName@/: The name of the property to get the value of.
    -> GVariant
    -- ^ /@value@/: The value to set the property to.
    -> GError
    -- ^ /@error@/: Return location for error.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to @/g_dbus_connection_register_object()/@.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the property was set to /@value@/, 'P.False' if /@error@/ is set.
dynamic_DBusInterfaceSetPropertyFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_DBusInterfaceSetPropertyFunc
-> a
-> Text
-> Text
-> Text
-> Text
-> GVariant
-> GError
-> Ptr ()
-> m Bool
dynamic_DBusInterfaceSetPropertyFunc FunPtr C_DBusInterfaceSetPropertyFunc
__funPtr a
connection Text
sender Text
objectPath Text
interfaceName Text
propertyName GVariant
value GError
error_ Ptr ()
userData = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    sender' <- textToCString sender
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    propertyName' <- textToCString propertyName
    value' <- unsafeManagedPtrGetPtr value
    error_' <- unsafeManagedPtrGetPtr error_
    result <- (__dynamic_C_DBusInterfaceSetPropertyFunc __funPtr) connection' sender' objectPath' interfaceName' propertyName' value' error_' userData
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr connection
    touchManagedPtr value
    touchManagedPtr error_
    freeMem sender'
    freeMem objectPath'
    freeMem interfaceName'
    freeMem propertyName'
    return result'

-- | Generate a function pointer callable from C code, from a `C_DBusInterfaceSetPropertyFunc`.
foreign import ccall "wrapper"
    mk_DBusInterfaceSetPropertyFunc :: C_DBusInterfaceSetPropertyFunc -> IO (FunPtr C_DBusInterfaceSetPropertyFunc)

-- | The type of the /@setProperty@/ function in t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
-- 
-- /Since: 2.26/
type DBusInterfaceSetPropertyFunc =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name for the property.
    -> T.Text
    -- ^ /@propertyName@/: The name of the property to get the value of.
    -> GVariant
    -- ^ /@value@/: The value to set the property to.
    -> GError
    -- ^ /@error@/: Return location for error.
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the property was set to /@value@/, 'P.False' if /@error@/ is set.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceSetPropertyFunc`@.
noDBusInterfaceSetPropertyFunc :: Maybe DBusInterfaceSetPropertyFunc
noDBusInterfaceSetPropertyFunc :: Maybe DBusInterfaceSetPropertyFunc
noDBusInterfaceSetPropertyFunc = Maybe DBusInterfaceSetPropertyFunc
forall a. Maybe a
Nothing

-- | The type of the /@setProperty@/ function in t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
-- 
-- /Since: 2.26/
type DBusInterfaceSetPropertyFunc_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name for the property.
    -> T.Text
    -- ^ /@propertyName@/: The name of the property to get the value of.
    -> GVariant
    -- ^ /@value@/: The value to set the property to.
    -> GError
    -- ^ /@error@/: Return location for error.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to @/g_dbus_connection_register_object()/@.
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the property was set to /@value@/, 'P.False' if /@error@/ is set.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceSetPropertyFunc_WithClosures`@.
noDBusInterfaceSetPropertyFunc_WithClosures :: Maybe DBusInterfaceSetPropertyFunc_WithClosures
noDBusInterfaceSetPropertyFunc_WithClosures :: Maybe DBusInterfaceSetPropertyFunc_WithClosures
noDBusInterfaceSetPropertyFunc_WithClosures = Maybe DBusInterfaceSetPropertyFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusInterfaceSetPropertyFunc :: DBusInterfaceSetPropertyFunc -> DBusInterfaceSetPropertyFunc_WithClosures
drop_closures_DBusInterfaceSetPropertyFunc :: DBusInterfaceSetPropertyFunc
-> DBusInterfaceSetPropertyFunc_WithClosures
drop_closures_DBusInterfaceSetPropertyFunc DBusInterfaceSetPropertyFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
propertyName GVariant
value GError
error_ Ptr ()
_ = DBusInterfaceSetPropertyFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
propertyName GVariant
value GError
error_

-- | Wrap the callback into a `GClosure`.
genClosure_DBusInterfaceSetPropertyFunc :: MonadIO m => DBusInterfaceSetPropertyFunc -> m (GClosure C_DBusInterfaceSetPropertyFunc)
genClosure_DBusInterfaceSetPropertyFunc :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceSetPropertyFunc
-> m (GClosure C_DBusInterfaceSetPropertyFunc)
genClosure_DBusInterfaceSetPropertyFunc DBusInterfaceSetPropertyFunc
cb = IO (GClosure C_DBusInterfaceSetPropertyFunc)
-> m (GClosure C_DBusInterfaceSetPropertyFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusInterfaceSetPropertyFunc)
 -> m (GClosure C_DBusInterfaceSetPropertyFunc))
-> IO (GClosure C_DBusInterfaceSetPropertyFunc)
-> m (GClosure C_DBusInterfaceSetPropertyFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusInterfaceSetPropertyFunc_WithClosures
cb' = DBusInterfaceSetPropertyFunc
-> DBusInterfaceSetPropertyFunc_WithClosures
drop_closures_DBusInterfaceSetPropertyFunc DBusInterfaceSetPropertyFunc
cb
    let cb'' :: C_DBusInterfaceSetPropertyFunc
cb'' = Maybe (Ptr (FunPtr C_DBusInterfaceSetPropertyFunc))
-> DBusInterfaceSetPropertyFunc_WithClosures
-> C_DBusInterfaceSetPropertyFunc
wrap_DBusInterfaceSetPropertyFunc Maybe (Ptr (FunPtr C_DBusInterfaceSetPropertyFunc))
forall a. Maybe a
Nothing DBusInterfaceSetPropertyFunc_WithClosures
cb'
    C_DBusInterfaceSetPropertyFunc
-> IO (FunPtr C_DBusInterfaceSetPropertyFunc)
mk_DBusInterfaceSetPropertyFunc C_DBusInterfaceSetPropertyFunc
cb'' IO (FunPtr C_DBusInterfaceSetPropertyFunc)
-> (FunPtr C_DBusInterfaceSetPropertyFunc
    -> IO (GClosure C_DBusInterfaceSetPropertyFunc))
-> IO (GClosure C_DBusInterfaceSetPropertyFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusInterfaceSetPropertyFunc
-> IO (GClosure C_DBusInterfaceSetPropertyFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusInterfaceSetPropertyFunc` into a `C_DBusInterfaceSetPropertyFunc`.
wrap_DBusInterfaceSetPropertyFunc :: 
    Maybe (Ptr (FunPtr C_DBusInterfaceSetPropertyFunc)) ->
    DBusInterfaceSetPropertyFunc_WithClosures ->
    C_DBusInterfaceSetPropertyFunc
wrap_DBusInterfaceSetPropertyFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceSetPropertyFunc))
-> DBusInterfaceSetPropertyFunc_WithClosures
-> C_DBusInterfaceSetPropertyFunc
wrap_DBusInterfaceSetPropertyFunc Maybe (Ptr (FunPtr C_DBusInterfaceSetPropertyFunc))
gi'funptrptr DBusInterfaceSetPropertyFunc_WithClosures
gi'cb Ptr DBusConnection
connection CString
sender CString
objectPath CString
interfaceName CString
propertyName Ptr GVariant
value Ptr GError
error_ Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    sender' <- cstringToText sender
    objectPath' <- cstringToText objectPath
    interfaceName' <- cstringToText interfaceName
    propertyName' <- cstringToText propertyName
    value' <- B.GVariant.newGVariantFromPtr value
    error_' <- (newBoxed GError) error_
    result <- gi'cb  connection' sender' objectPath' interfaceName' propertyName' value' error_' userData
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback DBusInterfaceMethodCallFunc
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "sender"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The unique bus name of the remote caller."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "The object path that the method was invoked on."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "interface_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "The D-Bus interface name the method was invoked on."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "method_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name of the method that was invoked."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "parameters"
          , argType = TVariant
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GVariant tuple with parameters."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "invocation"
          , argType =
              TInterface
                Name { namespace = "Gio" , name = "DBusMethodInvocation" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "A #GDBusMethodInvocation object that must be used to return a value or error."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferEverything
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The @user_data #gpointer passed to g_dbus_connection_register_object()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of the @method_call function in #GDBusInterfaceVTable."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusInterfaceMethodCallFunc =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    CString ->
    CString ->
    Ptr GVariant ->
    Ptr Gio.DBusMethodInvocation.DBusMethodInvocation ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sender"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The unique bus name of the remote caller."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The object path that the method was invoked on."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interface_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The D-Bus interface name the method was invoked on."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "method_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the method that was invoked."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parameters"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GVariant tuple with parameters."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "invocation"
--           , argType =
--               TInterface
--                 Name { namespace = "Gio" , name = "DBusMethodInvocation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GDBusMethodInvocation object that must be used to return a value or error."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The @user_data #gpointer passed to g_dbus_connection_register_object()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusInterfaceMethodCallFunc :: FunPtr C_DBusInterfaceMethodCallFunc -> C_DBusInterfaceMethodCallFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusInterfaceMethodCallFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a, Gio.DBusMethodInvocation.IsDBusMethodInvocation b) =>
    FunPtr C_DBusInterfaceMethodCallFunc
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name the method was invoked on.
    -> T.Text
    -- ^ /@methodName@/: The name of the method that was invoked.
    -> GVariant
    -- ^ /@parameters@/: A t'GVariant' tuple with parameters.
    -> b
    -- ^ /@invocation@/: A t'GI.Gio.Objects.DBusMethodInvocation.DBusMethodInvocation' object that must be used to return a value or error.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to @/g_dbus_connection_register_object()/@.
    -> m ()
dynamic_DBusInterfaceMethodCallFunc :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusConnection a,
 IsDBusMethodInvocation b) =>
FunPtr C_DBusInterfaceMethodCallFunc
-> a
-> Text
-> Text
-> Text
-> Text
-> GVariant
-> b
-> Ptr ()
-> m ()
dynamic_DBusInterfaceMethodCallFunc FunPtr C_DBusInterfaceMethodCallFunc
__funPtr a
connection Text
sender Text
objectPath Text
interfaceName Text
methodName GVariant
parameters b
invocation Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    sender' <- textToCString sender
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    methodName' <- textToCString methodName
    parameters' <- unsafeManagedPtrGetPtr parameters
    invocation' <- B.ManagedPtr.disownObject invocation
    (__dynamic_C_DBusInterfaceMethodCallFunc __funPtr) connection' sender' objectPath' interfaceName' methodName' parameters' invocation' userData
    touchManagedPtr connection
    touchManagedPtr parameters
    touchManagedPtr invocation
    freeMem sender'
    freeMem objectPath'
    freeMem interfaceName'
    freeMem methodName'
    return ()

-- | Generate a function pointer callable from C code, from a `C_DBusInterfaceMethodCallFunc`.
foreign import ccall "wrapper"
    mk_DBusInterfaceMethodCallFunc :: C_DBusInterfaceMethodCallFunc -> IO (FunPtr C_DBusInterfaceMethodCallFunc)

-- | The type of the /@methodCall@/ function in t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
-- 
-- /Since: 2.26/
type DBusInterfaceMethodCallFunc =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name the method was invoked on.
    -> T.Text
    -- ^ /@methodName@/: The name of the method that was invoked.
    -> GVariant
    -- ^ /@parameters@/: A t'GVariant' tuple with parameters.
    -> Gio.DBusMethodInvocation.DBusMethodInvocation
    -- ^ /@invocation@/: A t'GI.Gio.Objects.DBusMethodInvocation.DBusMethodInvocation' object that must be used to return a value or error.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceMethodCallFunc`@.
noDBusInterfaceMethodCallFunc :: Maybe DBusInterfaceMethodCallFunc
noDBusInterfaceMethodCallFunc :: Maybe DBusInterfaceMethodCallFunc
noDBusInterfaceMethodCallFunc = Maybe DBusInterfaceMethodCallFunc
forall a. Maybe a
Nothing

-- | The type of the /@methodCall@/ function in t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
-- 
-- /Since: 2.26/
type DBusInterfaceMethodCallFunc_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name the method was invoked on.
    -> T.Text
    -- ^ /@methodName@/: The name of the method that was invoked.
    -> GVariant
    -- ^ /@parameters@/: A t'GVariant' tuple with parameters.
    -> Gio.DBusMethodInvocation.DBusMethodInvocation
    -- ^ /@invocation@/: A t'GI.Gio.Objects.DBusMethodInvocation.DBusMethodInvocation' object that must be used to return a value or error.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to @/g_dbus_connection_register_object()/@.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceMethodCallFunc_WithClosures`@.
noDBusInterfaceMethodCallFunc_WithClosures :: Maybe DBusInterfaceMethodCallFunc_WithClosures
noDBusInterfaceMethodCallFunc_WithClosures :: Maybe DBusInterfaceMethodCallFunc_WithClosures
noDBusInterfaceMethodCallFunc_WithClosures = Maybe DBusInterfaceMethodCallFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusInterfaceMethodCallFunc :: DBusInterfaceMethodCallFunc -> DBusInterfaceMethodCallFunc_WithClosures
drop_closures_DBusInterfaceMethodCallFunc :: DBusInterfaceMethodCallFunc
-> DBusInterfaceMethodCallFunc_WithClosures
drop_closures_DBusInterfaceMethodCallFunc DBusInterfaceMethodCallFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
methodName GVariant
parameters DBusMethodInvocation
invocation Ptr ()
_ = DBusInterfaceMethodCallFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
methodName GVariant
parameters DBusMethodInvocation
invocation

-- | Wrap the callback into a `GClosure`.
genClosure_DBusInterfaceMethodCallFunc :: MonadIO m => DBusInterfaceMethodCallFunc -> m (GClosure C_DBusInterfaceMethodCallFunc)
genClosure_DBusInterfaceMethodCallFunc :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceMethodCallFunc
-> m (GClosure C_DBusInterfaceMethodCallFunc)
genClosure_DBusInterfaceMethodCallFunc DBusInterfaceMethodCallFunc
cb = IO (GClosure C_DBusInterfaceMethodCallFunc)
-> m (GClosure C_DBusInterfaceMethodCallFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusInterfaceMethodCallFunc)
 -> m (GClosure C_DBusInterfaceMethodCallFunc))
-> IO (GClosure C_DBusInterfaceMethodCallFunc)
-> m (GClosure C_DBusInterfaceMethodCallFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusInterfaceMethodCallFunc_WithClosures
cb' = DBusInterfaceMethodCallFunc
-> DBusInterfaceMethodCallFunc_WithClosures
drop_closures_DBusInterfaceMethodCallFunc DBusInterfaceMethodCallFunc
cb
    let cb'' :: C_DBusInterfaceMethodCallFunc
cb'' = Maybe (Ptr (FunPtr C_DBusInterfaceMethodCallFunc))
-> DBusInterfaceMethodCallFunc_WithClosures
-> C_DBusInterfaceMethodCallFunc
wrap_DBusInterfaceMethodCallFunc Maybe (Ptr (FunPtr C_DBusInterfaceMethodCallFunc))
forall a. Maybe a
Nothing DBusInterfaceMethodCallFunc_WithClosures
cb'
    C_DBusInterfaceMethodCallFunc
-> IO (FunPtr C_DBusInterfaceMethodCallFunc)
mk_DBusInterfaceMethodCallFunc C_DBusInterfaceMethodCallFunc
cb'' IO (FunPtr C_DBusInterfaceMethodCallFunc)
-> (FunPtr C_DBusInterfaceMethodCallFunc
    -> IO (GClosure C_DBusInterfaceMethodCallFunc))
-> IO (GClosure C_DBusInterfaceMethodCallFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusInterfaceMethodCallFunc
-> IO (GClosure C_DBusInterfaceMethodCallFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusInterfaceMethodCallFunc` into a `C_DBusInterfaceMethodCallFunc`.
wrap_DBusInterfaceMethodCallFunc :: 
    Maybe (Ptr (FunPtr C_DBusInterfaceMethodCallFunc)) ->
    DBusInterfaceMethodCallFunc_WithClosures ->
    C_DBusInterfaceMethodCallFunc
wrap_DBusInterfaceMethodCallFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceMethodCallFunc))
-> DBusInterfaceMethodCallFunc_WithClosures
-> C_DBusInterfaceMethodCallFunc
wrap_DBusInterfaceMethodCallFunc Maybe (Ptr (FunPtr C_DBusInterfaceMethodCallFunc))
gi'funptrptr DBusInterfaceMethodCallFunc_WithClosures
gi'cb Ptr DBusConnection
connection CString
sender CString
objectPath CString
interfaceName CString
methodName Ptr GVariant
parameters Ptr DBusMethodInvocation
invocation Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    sender' <- cstringToText sender
    objectPath' <- cstringToText objectPath
    interfaceName' <- cstringToText interfaceName
    methodName' <- cstringToText methodName
    parameters' <- B.GVariant.newGVariantFromPtr parameters
    invocation' <- (wrapObject Gio.DBusMethodInvocation.DBusMethodInvocation) invocation
    gi'cb  connection' sender' objectPath' interfaceName' methodName' parameters' invocation' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback DBusInterfaceGetPropertyFunc
{- Callable
  { returnType = Just TVariant
  , returnMayBeNull = False
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "A #GVariant with the value for @property_name or %NULL if\n    @error is set. If the returned #GVariant is floating, it is\n    consumed - otherwise its reference count is decreased by one."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "A #GDBusConnection."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "sender"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The unique bus name of the remote caller."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "object_path"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "The object path that the method was invoked on."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "interface_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The D-Bus interface name for the property."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "property_name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name of the property to get the value of."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "error"
          , argType = TError
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "Return location for error."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The @user_data #gpointer passed to g_dbus_connection_register_object()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of the @get_property function in #GDBusInterfaceVTable."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_DBusInterfaceGetPropertyFunc =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    CString ->
    CString ->
    Ptr GError ->
    Ptr () ->
    IO (Ptr GVariant)

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sender"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The unique bus name of the remote caller."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The object path that the method was invoked on."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interface_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The D-Bus interface name for the property."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the property to get the value of."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "error"
--           , argType = TError
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Return location for error."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The @user_data #gpointer passed to g_dbus_connection_register_object()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_DBusInterfaceGetPropertyFunc :: FunPtr C_DBusInterfaceGetPropertyFunc -> C_DBusInterfaceGetPropertyFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_DBusInterfaceGetPropertyFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_DBusInterfaceGetPropertyFunc
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name for the property.
    -> T.Text
    -- ^ /@propertyName@/: The name of the property to get the value of.
    -> GError
    -- ^ /@error@/: Return location for error.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to @/g_dbus_connection_register_object()/@.
    -> m GVariant
    -- ^ __Returns:__ A t'GVariant' with the value for /@propertyName@/ or 'P.Nothing' if
    --     /@error@/ is set. If the returned t'GVariant' is floating, it is
    --     consumed - otherwise its reference count is decreased by one.
dynamic_DBusInterfaceGetPropertyFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_DBusInterfaceGetPropertyFunc
-> a
-> Text
-> Text
-> Text
-> Text
-> GError
-> Ptr ()
-> m GVariant
dynamic_DBusInterfaceGetPropertyFunc FunPtr C_DBusInterfaceGetPropertyFunc
__funPtr a
connection Text
sender Text
objectPath Text
interfaceName Text
propertyName GError
error_ Ptr ()
userData = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    sender' <- textToCString sender
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    propertyName' <- textToCString propertyName
    error_' <- unsafeManagedPtrGetPtr error_
    result <- (__dynamic_C_DBusInterfaceGetPropertyFunc __funPtr) connection' sender' objectPath' interfaceName' propertyName' error_' userData
    checkUnexpectedReturnNULL "dBusInterfaceGetPropertyFunc" result
    result' <- B.GVariant.wrapGVariantPtr result
    touchManagedPtr connection
    touchManagedPtr error_
    freeMem sender'
    freeMem objectPath'
    freeMem interfaceName'
    freeMem propertyName'
    return result'

-- | Generate a function pointer callable from C code, from a `C_DBusInterfaceGetPropertyFunc`.
foreign import ccall "wrapper"
    mk_DBusInterfaceGetPropertyFunc :: C_DBusInterfaceGetPropertyFunc -> IO (FunPtr C_DBusInterfaceGetPropertyFunc)

-- | The type of the /@getProperty@/ function in t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
-- 
-- /Since: 2.26/
type DBusInterfaceGetPropertyFunc =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name for the property.
    -> T.Text
    -- ^ /@propertyName@/: The name of the property to get the value of.
    -> GError
    -- ^ /@error@/: Return location for error.
    -> IO GVariant
    -- ^ __Returns:__ A t'GVariant' with the value for /@propertyName@/ or 'P.Nothing' if
    --     /@error@/ is set. If the returned t'GVariant' is floating, it is
    --     consumed - otherwise its reference count is decreased by one.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceGetPropertyFunc`@.
noDBusInterfaceGetPropertyFunc :: Maybe DBusInterfaceGetPropertyFunc
noDBusInterfaceGetPropertyFunc :: Maybe DBusInterfaceGetPropertyFunc
noDBusInterfaceGetPropertyFunc = Maybe DBusInterfaceGetPropertyFunc
forall a. Maybe a
Nothing

-- | The type of the /@getProperty@/ function in t'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable'.
-- 
-- /Since: 2.26/
type DBusInterfaceGetPropertyFunc_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> T.Text
    -- ^ /@sender@/: The unique bus name of the remote caller.
    -> T.Text
    -- ^ /@objectPath@/: The object path that the method was invoked on.
    -> T.Text
    -- ^ /@interfaceName@/: The D-Bus interface name for the property.
    -> T.Text
    -- ^ /@propertyName@/: The name of the property to get the value of.
    -> GError
    -- ^ /@error@/: Return location for error.
    -> Ptr ()
    -- ^ /@userData@/: The /@userData@/ @/gpointer/@ passed to @/g_dbus_connection_register_object()/@.
    -> IO GVariant
    -- ^ __Returns:__ A t'GVariant' with the value for /@propertyName@/ or 'P.Nothing' if
    --     /@error@/ is set. If the returned t'GVariant' is floating, it is
    --     consumed - otherwise its reference count is decreased by one.

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceGetPropertyFunc_WithClosures`@.
noDBusInterfaceGetPropertyFunc_WithClosures :: Maybe DBusInterfaceGetPropertyFunc_WithClosures
noDBusInterfaceGetPropertyFunc_WithClosures :: Maybe DBusInterfaceGetPropertyFunc_WithClosures
noDBusInterfaceGetPropertyFunc_WithClosures = Maybe DBusInterfaceGetPropertyFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DBusInterfaceGetPropertyFunc :: DBusInterfaceGetPropertyFunc -> DBusInterfaceGetPropertyFunc_WithClosures
drop_closures_DBusInterfaceGetPropertyFunc :: DBusInterfaceGetPropertyFunc
-> DBusInterfaceGetPropertyFunc_WithClosures
drop_closures_DBusInterfaceGetPropertyFunc DBusInterfaceGetPropertyFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
propertyName GError
error_ Ptr ()
_ = DBusInterfaceGetPropertyFunc
_f DBusConnection
connection Text
sender Text
objectPath Text
interfaceName Text
propertyName GError
error_

-- | Wrap the callback into a `GClosure`.
genClosure_DBusInterfaceGetPropertyFunc :: MonadIO m => DBusInterfaceGetPropertyFunc -> m (GClosure C_DBusInterfaceGetPropertyFunc)
genClosure_DBusInterfaceGetPropertyFunc :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceGetPropertyFunc
-> m (GClosure C_DBusInterfaceGetPropertyFunc)
genClosure_DBusInterfaceGetPropertyFunc DBusInterfaceGetPropertyFunc
cb = IO (GClosure C_DBusInterfaceGetPropertyFunc)
-> m (GClosure C_DBusInterfaceGetPropertyFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DBusInterfaceGetPropertyFunc)
 -> m (GClosure C_DBusInterfaceGetPropertyFunc))
-> IO (GClosure C_DBusInterfaceGetPropertyFunc)
-> m (GClosure C_DBusInterfaceGetPropertyFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: DBusInterfaceGetPropertyFunc_WithClosures
cb' = DBusInterfaceGetPropertyFunc
-> DBusInterfaceGetPropertyFunc_WithClosures
drop_closures_DBusInterfaceGetPropertyFunc DBusInterfaceGetPropertyFunc
cb
    let cb'' :: C_DBusInterfaceGetPropertyFunc
cb'' = Maybe (Ptr (FunPtr C_DBusInterfaceGetPropertyFunc))
-> DBusInterfaceGetPropertyFunc_WithClosures
-> C_DBusInterfaceGetPropertyFunc
wrap_DBusInterfaceGetPropertyFunc Maybe (Ptr (FunPtr C_DBusInterfaceGetPropertyFunc))
forall a. Maybe a
Nothing DBusInterfaceGetPropertyFunc_WithClosures
cb'
    C_DBusInterfaceGetPropertyFunc
-> IO (FunPtr C_DBusInterfaceGetPropertyFunc)
mk_DBusInterfaceGetPropertyFunc C_DBusInterfaceGetPropertyFunc
cb'' IO (FunPtr C_DBusInterfaceGetPropertyFunc)
-> (FunPtr C_DBusInterfaceGetPropertyFunc
    -> IO (GClosure C_DBusInterfaceGetPropertyFunc))
-> IO (GClosure C_DBusInterfaceGetPropertyFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DBusInterfaceGetPropertyFunc
-> IO (GClosure C_DBusInterfaceGetPropertyFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `DBusInterfaceGetPropertyFunc` into a `C_DBusInterfaceGetPropertyFunc`.
wrap_DBusInterfaceGetPropertyFunc :: 
    Maybe (Ptr (FunPtr C_DBusInterfaceGetPropertyFunc)) ->
    DBusInterfaceGetPropertyFunc_WithClosures ->
    C_DBusInterfaceGetPropertyFunc
wrap_DBusInterfaceGetPropertyFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceGetPropertyFunc))
-> DBusInterfaceGetPropertyFunc_WithClosures
-> C_DBusInterfaceGetPropertyFunc
wrap_DBusInterfaceGetPropertyFunc Maybe (Ptr (FunPtr C_DBusInterfaceGetPropertyFunc))
gi'funptrptr DBusInterfaceGetPropertyFunc_WithClosures
gi'cb Ptr DBusConnection
connection CString
sender CString
objectPath CString
interfaceName CString
propertyName Ptr GError
error_ Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    sender' <- cstringToText sender
    objectPath' <- cstringToText objectPath
    interfaceName' <- cstringToText interfaceName
    propertyName' <- cstringToText propertyName
    error_' <- (newBoxed GError) error_
    result <- gi'cb  connection' sender' objectPath' interfaceName' propertyName' error_' userData
    maybeReleaseFunPtr gi'funptrptr
    result' <- B.GVariant.disownGVariant result
    return result'


-- callback CancellableSourceFunc
{- Callable
  { returnType = Just (TBasicType TBoolean)
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just "it should return %FALSE if the source should be removed."
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "cancellable"
          , argType =
              TInterface Name { namespace = "Gio" , name = "Cancellable" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "the #GCancellable" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "data passed in by the user."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "This is the function type of the callback used for the #GSource\nreturned by g_cancellable_source_new()."
        , sinceVersion = Just "2.28"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_CancellableSourceFunc =
    Ptr Gio.Cancellable.Cancellable ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GCancellable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data passed in by the user."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_CancellableSourceFunc :: FunPtr C_CancellableSourceFunc -> C_CancellableSourceFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CancellableSourceFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    FunPtr C_CancellableSourceFunc
    -> Maybe (a)
    -- ^ /@cancellable@/: the t'GI.Gio.Objects.Cancellable.Cancellable'
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> m Bool
    -- ^ __Returns:__ it should return 'P.False' if the source should be removed.
dynamic_CancellableSourceFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
FunPtr C_CancellableSourceFunc -> Maybe a -> Ptr () -> m Bool
dynamic_CancellableSourceFunc FunPtr C_CancellableSourceFunc
__funPtr Maybe a
cancellable Ptr ()
data_ = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    maybeCancellable <- case Maybe a
cancellable of
        Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just a
jCancellable -> do
            jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            return jCancellable'
    result <- (__dynamic_C_CancellableSourceFunc __funPtr) maybeCancellable data_
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    whenJust cancellable touchManagedPtr
    return result'

-- | Generate a function pointer callable from C code, from a `C_CancellableSourceFunc`.
foreign import ccall "wrapper"
    mk_CancellableSourceFunc :: C_CancellableSourceFunc -> IO (FunPtr C_CancellableSourceFunc)

-- | This is the function type of the callback used for the t'GI.GLib.Structs.Source.Source'
-- returned by 'GI.Gio.Objects.Cancellable.cancellableSourceNew'.
-- 
-- /Since: 2.28/
type CancellableSourceFunc =
    Maybe Gio.Cancellable.Cancellable
    -- ^ /@cancellable@/: the t'GI.Gio.Objects.Cancellable.Cancellable'
    -> Ptr ()
    -- ^ /@data@/: data passed in by the user.
    -> IO Bool
    -- ^ __Returns:__ it should return 'P.False' if the source should be removed.

-- | A convenience synonym for @`Nothing` :: `Maybe` `CancellableSourceFunc`@.
noCancellableSourceFunc :: Maybe CancellableSourceFunc
noCancellableSourceFunc :: Maybe CancellableSourceFunc
noCancellableSourceFunc = Maybe CancellableSourceFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_CancellableSourceFunc :: MonadIO m => CancellableSourceFunc -> m (GClosure C_CancellableSourceFunc)
genClosure_CancellableSourceFunc :: forall (m :: * -> *).
MonadIO m =>
CancellableSourceFunc -> m (GClosure C_CancellableSourceFunc)
genClosure_CancellableSourceFunc CancellableSourceFunc
cb = IO (GClosure C_CancellableSourceFunc)
-> m (GClosure C_CancellableSourceFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CancellableSourceFunc)
 -> m (GClosure C_CancellableSourceFunc))
-> IO (GClosure C_CancellableSourceFunc)
-> m (GClosure C_CancellableSourceFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CancellableSourceFunc
cb' = Maybe (Ptr (FunPtr C_CancellableSourceFunc))
-> CancellableSourceFunc -> C_CancellableSourceFunc
wrap_CancellableSourceFunc Maybe (Ptr (FunPtr C_CancellableSourceFunc))
forall a. Maybe a
Nothing CancellableSourceFunc
cb
    C_CancellableSourceFunc -> IO (FunPtr C_CancellableSourceFunc)
mk_CancellableSourceFunc C_CancellableSourceFunc
cb' IO (FunPtr C_CancellableSourceFunc)
-> (FunPtr C_CancellableSourceFunc
    -> IO (GClosure C_CancellableSourceFunc))
-> IO (GClosure C_CancellableSourceFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CancellableSourceFunc
-> IO (GClosure C_CancellableSourceFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CancellableSourceFunc` into a `C_CancellableSourceFunc`.
wrap_CancellableSourceFunc :: 
    Maybe (Ptr (FunPtr C_CancellableSourceFunc)) ->
    CancellableSourceFunc ->
    C_CancellableSourceFunc
wrap_CancellableSourceFunc :: Maybe (Ptr (FunPtr C_CancellableSourceFunc))
-> CancellableSourceFunc -> C_CancellableSourceFunc
wrap_CancellableSourceFunc Maybe (Ptr (FunPtr C_CancellableSourceFunc))
gi'funptrptr CancellableSourceFunc
gi'cb Ptr Cancellable
cancellable Ptr ()
data_ = do
    maybeCancellable <-
        if Ptr Cancellable
cancellable Ptr Cancellable -> Ptr Cancellable -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        then Maybe Cancellable -> IO (Maybe Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Cancellable
forall a. Maybe a
Nothing
        else do
            cancellable' <- ((ManagedPtr Cancellable -> Cancellable)
-> Ptr Cancellable -> IO Cancellable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Cancellable -> Cancellable
Gio.Cancellable.Cancellable) Ptr Cancellable
cancellable
            return $ Just cancellable'
    result <- gi'cb  maybeCancellable data_
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- callback BusNameVanishedCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The #GDBusConnection the name is being watched on, or\n    %NULL."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name being watched."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "User data passed to g_bus_watch_name()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Invoked when the name being watched is known not to have to have an owner.\n\nThis is also invoked when the #GDBusConnection on which the watch was\nestablished has been closed.  In that case, @connection will be\n%NULL."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_BusNameVanishedCallback =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GDBusConnection the name is being watched on, or\n    %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name being watched."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data passed to g_bus_watch_name()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BusNameVanishedCallback :: FunPtr C_BusNameVanishedCallback -> C_BusNameVanishedCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BusNameVanishedCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_BusNameVanishedCallback
    -> a
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' the name is being watched on, or
    --     'P.Nothing'.
    -> T.Text
    -- ^ /@name@/: The name being watched.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_watch_name()/@.
    -> m ()
dynamic_BusNameVanishedCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_BusNameVanishedCallback -> a -> Text -> Ptr () -> m ()
dynamic_BusNameVanishedCallback FunPtr C_BusNameVanishedCallback
__funPtr a
connection Text
name Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    name' <- textToCString name
    (__dynamic_C_BusNameVanishedCallback __funPtr) connection' name' userData
    touchManagedPtr connection
    freeMem name'
    return ()

-- | Generate a function pointer callable from C code, from a `C_BusNameVanishedCallback`.
foreign import ccall "wrapper"
    mk_BusNameVanishedCallback :: C_BusNameVanishedCallback -> IO (FunPtr C_BusNameVanishedCallback)

-- | Invoked when the name being watched is known not to have to have an owner.
-- 
-- This is also invoked when the t'GI.Gio.Objects.DBusConnection.DBusConnection' on which the watch was
-- established has been closed.  In that case, /@connection@/ will be
-- 'P.Nothing'.
-- 
-- /Since: 2.26/
type BusNameVanishedCallback =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' the name is being watched on, or
    --     'P.Nothing'.
    -> T.Text
    -- ^ /@name@/: The name being watched.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameVanishedCallback`@.
noBusNameVanishedCallback :: Maybe BusNameVanishedCallback
noBusNameVanishedCallback :: Maybe BusNameVanishedCallback
noBusNameVanishedCallback = Maybe BusNameVanishedCallback
forall a. Maybe a
Nothing

-- | Invoked when the name being watched is known not to have to have an owner.
-- 
-- This is also invoked when the t'GI.Gio.Objects.DBusConnection.DBusConnection' on which the watch was
-- established has been closed.  In that case, /@connection@/ will be
-- 'P.Nothing'.
-- 
-- /Since: 2.26/
type BusNameVanishedCallback_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' the name is being watched on, or
    --     'P.Nothing'.
    -> T.Text
    -- ^ /@name@/: The name being watched.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_watch_name()/@.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameVanishedCallback_WithClosures`@.
noBusNameVanishedCallback_WithClosures :: Maybe BusNameVanishedCallback_WithClosures
noBusNameVanishedCallback_WithClosures :: Maybe BusNameVanishedCallback_WithClosures
noBusNameVanishedCallback_WithClosures = Maybe BusNameVanishedCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BusNameVanishedCallback :: BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusNameVanishedCallback :: BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusNameVanishedCallback BusNameVanishedCallback
_f DBusConnection
connection Text
name Ptr ()
_ = BusNameVanishedCallback
_f DBusConnection
connection Text
name

-- | Wrap the callback into a `GClosure`.
genClosure_BusNameVanishedCallback :: MonadIO m => BusNameVanishedCallback -> m (GClosure C_BusNameVanishedCallback)
genClosure_BusNameVanishedCallback :: forall (m :: * -> *).
MonadIO m =>
BusNameVanishedCallback -> m (GClosure C_BusNameVanishedCallback)
genClosure_BusNameVanishedCallback BusNameVanishedCallback
cb = IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BusNameVanishedCallback)
 -> m (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: BusNameVanishedCallback_WithClosures
cb' = BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusNameVanishedCallback BusNameVanishedCallback
cb
    let cb'' :: C_BusNameVanishedCallback
cb'' = Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusNameVanishedCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
forall a. Maybe a
Nothing BusNameVanishedCallback_WithClosures
cb'
    C_BusNameVanishedCallback -> IO (FunPtr C_BusNameVanishedCallback)
mk_BusNameVanishedCallback C_BusNameVanishedCallback
cb'' IO (FunPtr C_BusNameVanishedCallback)
-> (FunPtr C_BusNameVanishedCallback
    -> IO (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BusNameVanishedCallback
-> IO (GClosure C_BusNameVanishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BusNameVanishedCallback` into a `C_BusNameVanishedCallback`.
wrap_BusNameVanishedCallback :: 
    Maybe (Ptr (FunPtr C_BusNameVanishedCallback)) ->
    BusNameVanishedCallback_WithClosures ->
    C_BusNameVanishedCallback
wrap_BusNameVanishedCallback :: Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusNameVanishedCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
gi'funptrptr BusNameVanishedCallback_WithClosures
gi'cb Ptr DBusConnection
connection CString
name Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    name' <- cstringToText name
    gi'cb  connection' name' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback BusNameLostCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "The #GDBusConnection on which to acquire the name or %NULL if\nthe connection was disconnected."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name being owned."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "User data passed to g_bus_own_name() or g_bus_own_name_on_connection()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Invoked when the name is lost or @connection has been closed."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_BusNameLostCallback =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GDBusConnection on which to acquire the name or %NULL if\nthe connection was disconnected."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name being owned."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "User data passed to g_bus_own_name() or g_bus_own_name_on_connection()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BusNameLostCallback :: FunPtr C_BusNameLostCallback -> C_BusNameLostCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BusNameLostCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_BusNameLostCallback
    -> a
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' on which to acquire the name or 'P.Nothing' if
    -- the connection was disconnected.
    -> T.Text
    -- ^ /@name@/: The name being owned.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_own_name()/@ or @/g_bus_own_name_on_connection()/@.
    -> m ()
dynamic_BusNameLostCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_BusNameVanishedCallback -> a -> Text -> Ptr () -> m ()
dynamic_BusNameLostCallback FunPtr C_BusNameVanishedCallback
__funPtr a
connection Text
name Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    name' <- textToCString name
    (__dynamic_C_BusNameLostCallback __funPtr) connection' name' userData
    touchManagedPtr connection
    freeMem name'
    return ()

-- | Generate a function pointer callable from C code, from a `C_BusNameLostCallback`.
foreign import ccall "wrapper"
    mk_BusNameLostCallback :: C_BusNameLostCallback -> IO (FunPtr C_BusNameLostCallback)

-- | Invoked when the name is lost or /@connection@/ has been closed.
-- 
-- /Since: 2.26/
type BusNameLostCallback =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' on which to acquire the name or 'P.Nothing' if
    -- the connection was disconnected.
    -> T.Text
    -- ^ /@name@/: The name being owned.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameLostCallback`@.
noBusNameLostCallback :: Maybe BusNameLostCallback
noBusNameLostCallback :: Maybe BusNameVanishedCallback
noBusNameLostCallback = Maybe BusNameVanishedCallback
forall a. Maybe a
Nothing

-- | Invoked when the name is lost or /@connection@/ has been closed.
-- 
-- /Since: 2.26/
type BusNameLostCallback_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' on which to acquire the name or 'P.Nothing' if
    -- the connection was disconnected.
    -> T.Text
    -- ^ /@name@/: The name being owned.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_own_name()/@ or @/g_bus_own_name_on_connection()/@.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameLostCallback_WithClosures`@.
noBusNameLostCallback_WithClosures :: Maybe BusNameLostCallback_WithClosures
noBusNameLostCallback_WithClosures :: Maybe BusNameVanishedCallback_WithClosures
noBusNameLostCallback_WithClosures = Maybe BusNameVanishedCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BusNameLostCallback :: BusNameLostCallback -> BusNameLostCallback_WithClosures
drop_closures_BusNameLostCallback :: BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusNameLostCallback BusNameVanishedCallback
_f DBusConnection
connection Text
name Ptr ()
_ = BusNameVanishedCallback
_f DBusConnection
connection Text
name

-- | Wrap the callback into a `GClosure`.
genClosure_BusNameLostCallback :: MonadIO m => BusNameLostCallback -> m (GClosure C_BusNameLostCallback)
genClosure_BusNameLostCallback :: forall (m :: * -> *).
MonadIO m =>
BusNameVanishedCallback -> m (GClosure C_BusNameVanishedCallback)
genClosure_BusNameLostCallback BusNameVanishedCallback
cb = IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BusNameVanishedCallback)
 -> m (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: BusNameVanishedCallback_WithClosures
cb' = BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusNameLostCallback BusNameVanishedCallback
cb
    let cb'' :: C_BusNameVanishedCallback
cb'' = Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusNameLostCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
forall a. Maybe a
Nothing BusNameVanishedCallback_WithClosures
cb'
    C_BusNameVanishedCallback -> IO (FunPtr C_BusNameVanishedCallback)
mk_BusNameLostCallback C_BusNameVanishedCallback
cb'' IO (FunPtr C_BusNameVanishedCallback)
-> (FunPtr C_BusNameVanishedCallback
    -> IO (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BusNameVanishedCallback
-> IO (GClosure C_BusNameVanishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BusNameLostCallback` into a `C_BusNameLostCallback`.
wrap_BusNameLostCallback :: 
    Maybe (Ptr (FunPtr C_BusNameLostCallback)) ->
    BusNameLostCallback_WithClosures ->
    C_BusNameLostCallback
wrap_BusNameLostCallback :: Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusNameLostCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
gi'funptrptr BusNameVanishedCallback_WithClosures
gi'cb Ptr DBusConnection
connection CString
name Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    name' <- cstringToText name
    gi'cb  connection' name' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback BusNameAppearedCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "The #GDBusConnection the name is being watched on."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name being watched."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "name_owner"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "Unique name of the owner of the name being watched."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "User data passed to g_bus_watch_name()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Invoked when the name being watched is known to have to have an owner."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_BusNameAppearedCallback =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    CString ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #GDBusConnection the name is being watched on."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name being watched."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name_owner"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Unique name of the owner of the name being watched."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data passed to g_bus_watch_name()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BusNameAppearedCallback :: FunPtr C_BusNameAppearedCallback -> C_BusNameAppearedCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BusNameAppearedCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_BusNameAppearedCallback
    -> a
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' the name is being watched on.
    -> T.Text
    -- ^ /@name@/: The name being watched.
    -> T.Text
    -- ^ /@nameOwner@/: Unique name of the owner of the name being watched.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_watch_name()/@.
    -> m ()
dynamic_BusNameAppearedCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_BusNameAppearedCallback
-> a -> Text -> Text -> Ptr () -> m ()
dynamic_BusNameAppearedCallback FunPtr C_BusNameAppearedCallback
__funPtr a
connection Text
name Text
nameOwner Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    name' <- textToCString name
    nameOwner' <- textToCString nameOwner
    (__dynamic_C_BusNameAppearedCallback __funPtr) connection' name' nameOwner' userData
    touchManagedPtr connection
    freeMem name'
    freeMem nameOwner'
    return ()

-- | Generate a function pointer callable from C code, from a `C_BusNameAppearedCallback`.
foreign import ccall "wrapper"
    mk_BusNameAppearedCallback :: C_BusNameAppearedCallback -> IO (FunPtr C_BusNameAppearedCallback)

-- | Invoked when the name being watched is known to have to have an owner.
-- 
-- /Since: 2.26/
type BusNameAppearedCallback =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' the name is being watched on.
    -> T.Text
    -- ^ /@name@/: The name being watched.
    -> T.Text
    -- ^ /@nameOwner@/: Unique name of the owner of the name being watched.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameAppearedCallback`@.
noBusNameAppearedCallback :: Maybe BusNameAppearedCallback
noBusNameAppearedCallback :: Maybe BusNameAppearedCallback
noBusNameAppearedCallback = Maybe BusNameAppearedCallback
forall a. Maybe a
Nothing

-- | Invoked when the name being watched is known to have to have an owner.
-- 
-- /Since: 2.26/
type BusNameAppearedCallback_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' the name is being watched on.
    -> T.Text
    -- ^ /@name@/: The name being watched.
    -> T.Text
    -- ^ /@nameOwner@/: Unique name of the owner of the name being watched.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_watch_name()/@.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameAppearedCallback_WithClosures`@.
noBusNameAppearedCallback_WithClosures :: Maybe BusNameAppearedCallback_WithClosures
noBusNameAppearedCallback_WithClosures :: Maybe BusNameAppearedCallback_WithClosures
noBusNameAppearedCallback_WithClosures = Maybe BusNameAppearedCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BusNameAppearedCallback :: BusNameAppearedCallback -> BusNameAppearedCallback_WithClosures
drop_closures_BusNameAppearedCallback :: BusNameAppearedCallback -> BusNameAppearedCallback_WithClosures
drop_closures_BusNameAppearedCallback BusNameAppearedCallback
_f DBusConnection
connection Text
name Text
nameOwner Ptr ()
_ = BusNameAppearedCallback
_f DBusConnection
connection Text
name Text
nameOwner

-- | Wrap the callback into a `GClosure`.
genClosure_BusNameAppearedCallback :: MonadIO m => BusNameAppearedCallback -> m (GClosure C_BusNameAppearedCallback)
genClosure_BusNameAppearedCallback :: forall (m :: * -> *).
MonadIO m =>
BusNameAppearedCallback -> m (GClosure C_BusNameAppearedCallback)
genClosure_BusNameAppearedCallback BusNameAppearedCallback
cb = IO (GClosure C_BusNameAppearedCallback)
-> m (GClosure C_BusNameAppearedCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BusNameAppearedCallback)
 -> m (GClosure C_BusNameAppearedCallback))
-> IO (GClosure C_BusNameAppearedCallback)
-> m (GClosure C_BusNameAppearedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: BusNameAppearedCallback_WithClosures
cb' = BusNameAppearedCallback -> BusNameAppearedCallback_WithClosures
drop_closures_BusNameAppearedCallback BusNameAppearedCallback
cb
    let cb'' :: C_BusNameAppearedCallback
cb'' = Maybe (Ptr (FunPtr C_BusNameAppearedCallback))
-> BusNameAppearedCallback_WithClosures
-> C_BusNameAppearedCallback
wrap_BusNameAppearedCallback Maybe (Ptr (FunPtr C_BusNameAppearedCallback))
forall a. Maybe a
Nothing BusNameAppearedCallback_WithClosures
cb'
    C_BusNameAppearedCallback -> IO (FunPtr C_BusNameAppearedCallback)
mk_BusNameAppearedCallback C_BusNameAppearedCallback
cb'' IO (FunPtr C_BusNameAppearedCallback)
-> (FunPtr C_BusNameAppearedCallback
    -> IO (GClosure C_BusNameAppearedCallback))
-> IO (GClosure C_BusNameAppearedCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BusNameAppearedCallback
-> IO (GClosure C_BusNameAppearedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BusNameAppearedCallback` into a `C_BusNameAppearedCallback`.
wrap_BusNameAppearedCallback :: 
    Maybe (Ptr (FunPtr C_BusNameAppearedCallback)) ->
    BusNameAppearedCallback_WithClosures ->
    C_BusNameAppearedCallback
wrap_BusNameAppearedCallback :: Maybe (Ptr (FunPtr C_BusNameAppearedCallback))
-> BusNameAppearedCallback_WithClosures
-> C_BusNameAppearedCallback
wrap_BusNameAppearedCallback Maybe (Ptr (FunPtr C_BusNameAppearedCallback))
gi'funptrptr BusNameAppearedCallback_WithClosures
gi'cb Ptr DBusConnection
connection CString
name CString
nameOwner Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    name' <- cstringToText name
    nameOwner' <- cstringToText nameOwner
    gi'cb  connection' name' nameOwner' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback BusNameAcquiredCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText =
                    Just "The #GDBusConnection on which to acquired the name."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name being owned."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just
                      "User data passed to g_bus_own_name() or g_bus_own_name_on_connection()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText = Just "Invoked when the name is acquired."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_BusNameAcquiredCallback =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #GDBusConnection on which to acquired the name."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name being owned."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "User data passed to g_bus_own_name() or g_bus_own_name_on_connection()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BusNameAcquiredCallback :: FunPtr C_BusNameAcquiredCallback -> C_BusNameAcquiredCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BusNameAcquiredCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_BusNameAcquiredCallback
    -> a
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' on which to acquired the name.
    -> T.Text
    -- ^ /@name@/: The name being owned.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_own_name()/@ or @/g_bus_own_name_on_connection()/@.
    -> m ()
dynamic_BusNameAcquiredCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_BusNameVanishedCallback -> a -> Text -> Ptr () -> m ()
dynamic_BusNameAcquiredCallback FunPtr C_BusNameVanishedCallback
__funPtr a
connection Text
name Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    name' <- textToCString name
    (__dynamic_C_BusNameAcquiredCallback __funPtr) connection' name' userData
    touchManagedPtr connection
    freeMem name'
    return ()

-- | Generate a function pointer callable from C code, from a `C_BusNameAcquiredCallback`.
foreign import ccall "wrapper"
    mk_BusNameAcquiredCallback :: C_BusNameAcquiredCallback -> IO (FunPtr C_BusNameAcquiredCallback)

-- | Invoked when the name is acquired.
-- 
-- /Since: 2.26/
type BusNameAcquiredCallback =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' on which to acquired the name.
    -> T.Text
    -- ^ /@name@/: The name being owned.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameAcquiredCallback`@.
noBusNameAcquiredCallback :: Maybe BusNameAcquiredCallback
noBusNameAcquiredCallback :: Maybe BusNameVanishedCallback
noBusNameAcquiredCallback = Maybe BusNameVanishedCallback
forall a. Maybe a
Nothing

-- | Invoked when the name is acquired.
-- 
-- /Since: 2.26/
type BusNameAcquiredCallback_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' on which to acquired the name.
    -> T.Text
    -- ^ /@name@/: The name being owned.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_own_name()/@ or @/g_bus_own_name_on_connection()/@.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusNameAcquiredCallback_WithClosures`@.
noBusNameAcquiredCallback_WithClosures :: Maybe BusNameAcquiredCallback_WithClosures
noBusNameAcquiredCallback_WithClosures :: Maybe BusNameVanishedCallback_WithClosures
noBusNameAcquiredCallback_WithClosures = Maybe BusNameVanishedCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BusNameAcquiredCallback :: BusNameAcquiredCallback -> BusNameAcquiredCallback_WithClosures
drop_closures_BusNameAcquiredCallback :: BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusNameAcquiredCallback BusNameVanishedCallback
_f DBusConnection
connection Text
name Ptr ()
_ = BusNameVanishedCallback
_f DBusConnection
connection Text
name

-- | Wrap the callback into a `GClosure`.
genClosure_BusNameAcquiredCallback :: MonadIO m => BusNameAcquiredCallback -> m (GClosure C_BusNameAcquiredCallback)
genClosure_BusNameAcquiredCallback :: forall (m :: * -> *).
MonadIO m =>
BusNameVanishedCallback -> m (GClosure C_BusNameVanishedCallback)
genClosure_BusNameAcquiredCallback BusNameVanishedCallback
cb = IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BusNameVanishedCallback)
 -> m (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: BusNameVanishedCallback_WithClosures
cb' = BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusNameAcquiredCallback BusNameVanishedCallback
cb
    let cb'' :: C_BusNameVanishedCallback
cb'' = Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusNameAcquiredCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
forall a. Maybe a
Nothing BusNameVanishedCallback_WithClosures
cb'
    C_BusNameVanishedCallback -> IO (FunPtr C_BusNameVanishedCallback)
mk_BusNameAcquiredCallback C_BusNameVanishedCallback
cb'' IO (FunPtr C_BusNameVanishedCallback)
-> (FunPtr C_BusNameVanishedCallback
    -> IO (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BusNameVanishedCallback
-> IO (GClosure C_BusNameVanishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BusNameAcquiredCallback` into a `C_BusNameAcquiredCallback`.
wrap_BusNameAcquiredCallback :: 
    Maybe (Ptr (FunPtr C_BusNameAcquiredCallback)) ->
    BusNameAcquiredCallback_WithClosures ->
    C_BusNameAcquiredCallback
wrap_BusNameAcquiredCallback :: Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusNameAcquiredCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
gi'funptrptr BusNameVanishedCallback_WithClosures
gi'cb Ptr DBusConnection
connection CString
name Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    name' <- cstringToText name
    gi'cb  connection' name' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback BusAcquiredCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "connection"
          , argType =
              TInterface Name { namespace = "Gio" , name = "DBusConnection" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The #GDBusConnection to a message bus."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "name"
          , argType = TBasicType TUTF8
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "The name that is requested to be owned."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "User data passed to g_bus_own_name()."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Invoked when a connection to a message bus has been obtained."
        , sinceVersion = Just "2.26"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_BusAcquiredCallback =
    Ptr Gio.DBusConnection.DBusConnection ->
    CString ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GDBusConnection to a message bus."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name that is requested to be owned."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data passed to g_bus_own_name()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BusAcquiredCallback :: FunPtr C_BusAcquiredCallback -> C_BusAcquiredCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BusAcquiredCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    FunPtr C_BusAcquiredCallback
    -> a
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' to a message bus.
    -> T.Text
    -- ^ /@name@/: The name that is requested to be owned.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_own_name()/@.
    -> m ()
dynamic_BusAcquiredCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
FunPtr C_BusNameVanishedCallback -> a -> Text -> Ptr () -> m ()
dynamic_BusAcquiredCallback FunPtr C_BusNameVanishedCallback
__funPtr a
connection Text
name Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    name' <- textToCString name
    (__dynamic_C_BusAcquiredCallback __funPtr) connection' name' userData
    touchManagedPtr connection
    freeMem name'
    return ()

-- | Generate a function pointer callable from C code, from a `C_BusAcquiredCallback`.
foreign import ccall "wrapper"
    mk_BusAcquiredCallback :: C_BusAcquiredCallback -> IO (FunPtr C_BusAcquiredCallback)

-- | Invoked when a connection to a message bus has been obtained.
-- 
-- /Since: 2.26/
type BusAcquiredCallback =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' to a message bus.
    -> T.Text
    -- ^ /@name@/: The name that is requested to be owned.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusAcquiredCallback`@.
noBusAcquiredCallback :: Maybe BusAcquiredCallback
noBusAcquiredCallback :: Maybe BusNameVanishedCallback
noBusAcquiredCallback = Maybe BusNameVanishedCallback
forall a. Maybe a
Nothing

-- | Invoked when a connection to a message bus has been obtained.
-- 
-- /Since: 2.26/
type BusAcquiredCallback_WithClosures =
    Gio.DBusConnection.DBusConnection
    -- ^ /@connection@/: The t'GI.Gio.Objects.DBusConnection.DBusConnection' to a message bus.
    -> T.Text
    -- ^ /@name@/: The name that is requested to be owned.
    -> Ptr ()
    -- ^ /@userData@/: User data passed to @/g_bus_own_name()/@.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BusAcquiredCallback_WithClosures`@.
noBusAcquiredCallback_WithClosures :: Maybe BusAcquiredCallback_WithClosures
noBusAcquiredCallback_WithClosures :: Maybe BusNameVanishedCallback_WithClosures
noBusAcquiredCallback_WithClosures = Maybe BusNameVanishedCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BusAcquiredCallback :: BusAcquiredCallback -> BusAcquiredCallback_WithClosures
drop_closures_BusAcquiredCallback :: BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusAcquiredCallback BusNameVanishedCallback
_f DBusConnection
connection Text
name Ptr ()
_ = BusNameVanishedCallback
_f DBusConnection
connection Text
name

-- | Wrap the callback into a `GClosure`.
genClosure_BusAcquiredCallback :: MonadIO m => BusAcquiredCallback -> m (GClosure C_BusAcquiredCallback)
genClosure_BusAcquiredCallback :: forall (m :: * -> *).
MonadIO m =>
BusNameVanishedCallback -> m (GClosure C_BusNameVanishedCallback)
genClosure_BusAcquiredCallback BusNameVanishedCallback
cb = IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BusNameVanishedCallback)
 -> m (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
-> m (GClosure C_BusNameVanishedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: BusNameVanishedCallback_WithClosures
cb' = BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
drop_closures_BusAcquiredCallback BusNameVanishedCallback
cb
    let cb'' :: C_BusNameVanishedCallback
cb'' = Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusAcquiredCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
forall a. Maybe a
Nothing BusNameVanishedCallback_WithClosures
cb'
    C_BusNameVanishedCallback -> IO (FunPtr C_BusNameVanishedCallback)
mk_BusAcquiredCallback C_BusNameVanishedCallback
cb'' IO (FunPtr C_BusNameVanishedCallback)
-> (FunPtr C_BusNameVanishedCallback
    -> IO (GClosure C_BusNameVanishedCallback))
-> IO (GClosure C_BusNameVanishedCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BusNameVanishedCallback
-> IO (GClosure C_BusNameVanishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BusAcquiredCallback` into a `C_BusAcquiredCallback`.
wrap_BusAcquiredCallback :: 
    Maybe (Ptr (FunPtr C_BusAcquiredCallback)) ->
    BusAcquiredCallback_WithClosures ->
    C_BusAcquiredCallback
wrap_BusAcquiredCallback :: Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
-> BusNameVanishedCallback_WithClosures
-> C_BusNameVanishedCallback
wrap_BusAcquiredCallback Maybe (Ptr (FunPtr C_BusNameVanishedCallback))
gi'funptrptr BusNameVanishedCallback_WithClosures
gi'cb Ptr DBusConnection
connection CString
name Ptr ()
userData = do
    connection' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
connection
    name' <- cstringToText name
    gi'cb  connection' name' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback AsyncReadyCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "source_object"
          , argType =
              TInterface Name { namespace = "GObject" , name = "Object" }
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText =
                    Just "the object the asynchronous operation was started with."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "res"
          , argType =
              TInterface Name { namespace = "Gio" , name = "AsyncResult" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "user data passed to the callback."
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Type definition for a function that will be called back when an asynchronous\noperation within GIO has been completed. #GAsyncReadyCallback\ncallbacks from #GTask are guaranteed to be invoked in a later\niteration of the\n[thread-default main context][g-main-context-push-thread-default]\nwhere the #GTask was created. All other users of\n#GAsyncReadyCallback must likewise call it asynchronously in a\nlater iteration of the main context.\n\nThe asynchronous operation is guaranteed to have held a reference to\n@source_object from the time when the `*_async()` function was called, until\nafter this callback returns."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_AsyncReadyCallback =
    Ptr GObject.Object.Object ->
    Ptr Gio.AsyncResult.AsyncResult ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "source_object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the object the asynchronous operation was started with."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed to the callback."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_AsyncReadyCallback :: FunPtr C_AsyncReadyCallback -> C_AsyncReadyCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_AsyncReadyCallback ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a, Gio.AsyncResult.IsAsyncResult b) =>
    FunPtr C_AsyncReadyCallback
    -> Maybe (a)
    -- ^ /@sourceObject@/: the object the asynchronous operation was started with.
    -> b
    -- ^ /@res@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> Ptr ()
    -- ^ /@data@/: user data passed to the callback.
    -> m ()
dynamic_AsyncReadyCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsAsyncResult b) =>
FunPtr C_AsyncReadyCallback -> Maybe a -> b -> Ptr () -> m ()
dynamic_AsyncReadyCallback FunPtr C_AsyncReadyCallback
__funPtr Maybe a
sourceObject b
res Ptr ()
data_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    maybeSourceObject <- case Maybe a
sourceObject of
        Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
FP.nullPtr
        Just a
jSourceObject -> do
            jSourceObject' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSourceObject
            return jSourceObject'
    res' <- unsafeManagedPtrCastPtr res
    (__dynamic_C_AsyncReadyCallback __funPtr) maybeSourceObject res' data_
    whenJust sourceObject touchManagedPtr
    touchManagedPtr res
    return ()

-- | Generate a function pointer callable from C code, from a `C_AsyncReadyCallback`.
foreign import ccall "wrapper"
    mk_AsyncReadyCallback :: C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)

-- | Type definition for a function that will be called back when an asynchronous
-- operation within GIO has been completed. t'GI.Gio.Callbacks.AsyncReadyCallback'
-- callbacks from t'GI.Gio.Objects.Task.Task' are guaranteed to be invoked in a later
-- iteration of the
-- [thread-default main context][g-main-context-push-thread-default]
-- where the t'GI.Gio.Objects.Task.Task' was created. All other users of
-- t'GI.Gio.Callbacks.AsyncReadyCallback' must likewise call it asynchronously in a
-- later iteration of the main context.
-- 
-- The asynchronous operation is guaranteed to have held a reference to
-- /@sourceObject@/ from the time when the @*_async()@ function was called, until
-- after this callback returns.
type AsyncReadyCallback =
    Maybe GObject.Object.Object
    -- ^ /@sourceObject@/: the object the asynchronous operation was started with.
    -> Gio.AsyncResult.AsyncResult
    -- ^ /@res@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AsyncReadyCallback`@.
noAsyncReadyCallback :: Maybe AsyncReadyCallback
noAsyncReadyCallback :: Maybe AsyncReadyCallback
noAsyncReadyCallback = Maybe AsyncReadyCallback
forall a. Maybe a
Nothing

-- | Type definition for a function that will be called back when an asynchronous
-- operation within GIO has been completed. t'GI.Gio.Callbacks.AsyncReadyCallback'
-- callbacks from t'GI.Gio.Objects.Task.Task' are guaranteed to be invoked in a later
-- iteration of the
-- [thread-default main context][g-main-context-push-thread-default]
-- where the t'GI.Gio.Objects.Task.Task' was created. All other users of
-- t'GI.Gio.Callbacks.AsyncReadyCallback' must likewise call it asynchronously in a
-- later iteration of the main context.
-- 
-- The asynchronous operation is guaranteed to have held a reference to
-- /@sourceObject@/ from the time when the @*_async()@ function was called, until
-- after this callback returns.
type AsyncReadyCallback_WithClosures =
    Maybe GObject.Object.Object
    -- ^ /@sourceObject@/: the object the asynchronous operation was started with.
    -> Gio.AsyncResult.AsyncResult
    -- ^ /@res@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> Ptr ()
    -- ^ /@data@/: user data passed to the callback.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AsyncReadyCallback_WithClosures`@.
noAsyncReadyCallback_WithClosures :: Maybe AsyncReadyCallback_WithClosures
noAsyncReadyCallback_WithClosures :: Maybe AsyncReadyCallback_WithClosures
noAsyncReadyCallback_WithClosures = Maybe AsyncReadyCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AsyncReadyCallback :: AsyncReadyCallback -> AsyncReadyCallback_WithClosures
drop_closures_AsyncReadyCallback :: AsyncReadyCallback -> AsyncReadyCallback_WithClosures
drop_closures_AsyncReadyCallback AsyncReadyCallback
_f Maybe Object
sourceObject AsyncResult
res Ptr ()
_ = AsyncReadyCallback
_f Maybe Object
sourceObject AsyncResult
res

-- | Wrap the callback into a `GClosure`.
genClosure_AsyncReadyCallback :: MonadIO m => AsyncReadyCallback -> m (GClosure C_AsyncReadyCallback)
genClosure_AsyncReadyCallback :: forall (m :: * -> *).
MonadIO m =>
AsyncReadyCallback -> m (GClosure C_AsyncReadyCallback)
genClosure_AsyncReadyCallback AsyncReadyCallback
cb = IO (GClosure C_AsyncReadyCallback)
-> m (GClosure C_AsyncReadyCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AsyncReadyCallback)
 -> m (GClosure C_AsyncReadyCallback))
-> IO (GClosure C_AsyncReadyCallback)
-> m (GClosure C_AsyncReadyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: AsyncReadyCallback_WithClosures
cb' = AsyncReadyCallback -> AsyncReadyCallback_WithClosures
drop_closures_AsyncReadyCallback AsyncReadyCallback
cb
    let cb'' :: C_AsyncReadyCallback
cb'' = Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
wrap_AsyncReadyCallback Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Maybe a
Nothing AsyncReadyCallback_WithClosures
cb'
    C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
mk_AsyncReadyCallback C_AsyncReadyCallback
cb'' IO (FunPtr C_AsyncReadyCallback)
-> (FunPtr C_AsyncReadyCallback
    -> IO (GClosure C_AsyncReadyCallback))
-> IO (GClosure C_AsyncReadyCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AsyncReadyCallback -> IO (GClosure C_AsyncReadyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AsyncReadyCallback` into a `C_AsyncReadyCallback`.
wrap_AsyncReadyCallback :: 
    Maybe (Ptr (FunPtr C_AsyncReadyCallback)) ->
    AsyncReadyCallback_WithClosures ->
    C_AsyncReadyCallback
wrap_AsyncReadyCallback :: Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
wrap_AsyncReadyCallback Maybe (Ptr (FunPtr C_AsyncReadyCallback))
gi'funptrptr AsyncReadyCallback_WithClosures
gi'cb Ptr Object
sourceObject Ptr AsyncResult
res Ptr ()
data_ = do
    maybeSourceObject <-
        if Ptr Object
sourceObject Ptr Object -> Ptr Object -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Object
forall a. Ptr a
FP.nullPtr
        then Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
forall a. Maybe a
Nothing
        else do
            sourceObject' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
sourceObject
            return $ Just sourceObject'
    res' <- (newObject Gio.AsyncResult.AsyncResult) res
    gi'cb  maybeSourceObject res' data_
    maybeReleaseFunPtr gi'funptrptr


-- callback ActionEntryChangeStateFieldCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "action"
          , argType =
              TInterface Name { namespace = "Gio" , name = "SimpleAction" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "value"
          , argType = TVariant
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_ActionEntryChangeStateFieldCallback =
    Ptr Gio.SimpleAction.SimpleAction ->
    Ptr GVariant ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "SimpleAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ActionEntryChangeStateFieldCallback :: FunPtr C_ActionEntryChangeStateFieldCallback -> C_ActionEntryChangeStateFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ActionEntryChangeStateFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.SimpleAction.IsSimpleAction a) =>
    FunPtr C_ActionEntryChangeStateFieldCallback
    -> a
    -> GVariant
    -> Ptr ()
    -> m ()
dynamic_ActionEntryChangeStateFieldCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSimpleAction a) =>
FunPtr C_ActionEntryChangeStateFieldCallback
-> a -> GVariant -> Ptr () -> m ()
dynamic_ActionEntryChangeStateFieldCallback FunPtr C_ActionEntryChangeStateFieldCallback
__funPtr a
action GVariant
value Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    action' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
    value' <- unsafeManagedPtrGetPtr value
    (__dynamic_C_ActionEntryChangeStateFieldCallback __funPtr) action' value' userData
    touchManagedPtr action
    touchManagedPtr value
    return ()

-- | Generate a function pointer callable from C code, from a `C_ActionEntryChangeStateFieldCallback`.
foreign import ccall "wrapper"
    mk_ActionEntryChangeStateFieldCallback :: C_ActionEntryChangeStateFieldCallback -> IO (FunPtr C_ActionEntryChangeStateFieldCallback)

-- | /No description available in the introspection data./
type ActionEntryChangeStateFieldCallback =
    Gio.SimpleAction.SimpleAction
    -> GVariant
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ActionEntryChangeStateFieldCallback`@.
noActionEntryChangeStateFieldCallback :: Maybe ActionEntryChangeStateFieldCallback
noActionEntryChangeStateFieldCallback :: Maybe ActionEntryChangeStateFieldCallback
noActionEntryChangeStateFieldCallback = Maybe ActionEntryChangeStateFieldCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type ActionEntryChangeStateFieldCallback_WithClosures =
    Gio.SimpleAction.SimpleAction
    -> GVariant
    -> Ptr ()
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ActionEntryChangeStateFieldCallback_WithClosures`@.
noActionEntryChangeStateFieldCallback_WithClosures :: Maybe ActionEntryChangeStateFieldCallback_WithClosures
noActionEntryChangeStateFieldCallback_WithClosures :: Maybe ActionEntryChangeStateFieldCallback_WithClosures
noActionEntryChangeStateFieldCallback_WithClosures = Maybe ActionEntryChangeStateFieldCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ActionEntryChangeStateFieldCallback :: ActionEntryChangeStateFieldCallback -> ActionEntryChangeStateFieldCallback_WithClosures
drop_closures_ActionEntryChangeStateFieldCallback :: ActionEntryChangeStateFieldCallback
-> ActionEntryChangeStateFieldCallback_WithClosures
drop_closures_ActionEntryChangeStateFieldCallback ActionEntryChangeStateFieldCallback
_f SimpleAction
action GVariant
value Ptr ()
_ = ActionEntryChangeStateFieldCallback
_f SimpleAction
action GVariant
value

-- | Wrap the callback into a `GClosure`.
genClosure_ActionEntryChangeStateFieldCallback :: MonadIO m => ActionEntryChangeStateFieldCallback -> m (GClosure C_ActionEntryChangeStateFieldCallback)
genClosure_ActionEntryChangeStateFieldCallback :: forall (m :: * -> *).
MonadIO m =>
ActionEntryChangeStateFieldCallback
-> m (GClosure C_ActionEntryChangeStateFieldCallback)
genClosure_ActionEntryChangeStateFieldCallback ActionEntryChangeStateFieldCallback
cb = IO (GClosure C_ActionEntryChangeStateFieldCallback)
-> m (GClosure C_ActionEntryChangeStateFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ActionEntryChangeStateFieldCallback)
 -> m (GClosure C_ActionEntryChangeStateFieldCallback))
-> IO (GClosure C_ActionEntryChangeStateFieldCallback)
-> m (GClosure C_ActionEntryChangeStateFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: ActionEntryChangeStateFieldCallback_WithClosures
cb' = ActionEntryChangeStateFieldCallback
-> ActionEntryChangeStateFieldCallback_WithClosures
drop_closures_ActionEntryChangeStateFieldCallback ActionEntryChangeStateFieldCallback
cb
    let cb'' :: C_ActionEntryChangeStateFieldCallback
cb'' = Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
-> ActionEntryChangeStateFieldCallback_WithClosures
-> C_ActionEntryChangeStateFieldCallback
wrap_ActionEntryChangeStateFieldCallback Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
forall a. Maybe a
Nothing ActionEntryChangeStateFieldCallback_WithClosures
cb'
    C_ActionEntryChangeStateFieldCallback
-> IO (FunPtr C_ActionEntryChangeStateFieldCallback)
mk_ActionEntryChangeStateFieldCallback C_ActionEntryChangeStateFieldCallback
cb'' IO (FunPtr C_ActionEntryChangeStateFieldCallback)
-> (FunPtr C_ActionEntryChangeStateFieldCallback
    -> IO (GClosure C_ActionEntryChangeStateFieldCallback))
-> IO (GClosure C_ActionEntryChangeStateFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ActionEntryChangeStateFieldCallback
-> IO (GClosure C_ActionEntryChangeStateFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ActionEntryChangeStateFieldCallback` into a `C_ActionEntryChangeStateFieldCallback`.
wrap_ActionEntryChangeStateFieldCallback :: 
    Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback)) ->
    ActionEntryChangeStateFieldCallback_WithClosures ->
    C_ActionEntryChangeStateFieldCallback
wrap_ActionEntryChangeStateFieldCallback :: Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
-> ActionEntryChangeStateFieldCallback_WithClosures
-> C_ActionEntryChangeStateFieldCallback
wrap_ActionEntryChangeStateFieldCallback Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
gi'funptrptr ActionEntryChangeStateFieldCallback_WithClosures
gi'cb Ptr SimpleAction
action Ptr GVariant
value Ptr ()
userData = do
    action' <- ((ManagedPtr SimpleAction -> SimpleAction)
-> Ptr SimpleAction -> IO SimpleAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SimpleAction -> SimpleAction
Gio.SimpleAction.SimpleAction) Ptr SimpleAction
action
    value' <- B.GVariant.newGVariantFromPtr value
    gi'cb  action' value' userData
    maybeReleaseFunPtr gi'funptrptr


-- callback ActionEntryActivateFieldCallback
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "action"
          , argType =
              TInterface Name { namespace = "Gio" , name = "SimpleAction" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "parameter"
          , argType = TVariant
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "user_data"
          , argType = TBasicType TPtr
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_ActionEntryActivateFieldCallback =
    Ptr Gio.SimpleAction.SimpleAction ->
    Ptr GVariant ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "SimpleAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parameter"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ActionEntryActivateFieldCallback :: FunPtr C_ActionEntryActivateFieldCallback -> C_ActionEntryActivateFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ActionEntryActivateFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.SimpleAction.IsSimpleAction a) =>
    FunPtr C_ActionEntryActivateFieldCallback
    -> a
    -> Maybe (GVariant)
    -> Ptr ()
    -> m ()
dynamic_ActionEntryActivateFieldCallback :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSimpleAction a) =>
FunPtr C_ActionEntryChangeStateFieldCallback
-> a -> Maybe GVariant -> Ptr () -> m ()
dynamic_ActionEntryActivateFieldCallback FunPtr C_ActionEntryChangeStateFieldCallback
__funPtr a
action Maybe GVariant
parameter Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    action' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
    maybeParameter <- case parameter of
        Maybe GVariant
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
FP.nullPtr
        Just GVariant
jParameter -> do
            jParameter' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jParameter
            return jParameter'
    (__dynamic_C_ActionEntryActivateFieldCallback __funPtr) action' maybeParameter userData
    touchManagedPtr action
    whenJust parameter touchManagedPtr
    return ()

-- | Generate a function pointer callable from C code, from a `C_ActionEntryActivateFieldCallback`.
foreign import ccall "wrapper"
    mk_ActionEntryActivateFieldCallback :: C_ActionEntryActivateFieldCallback -> IO (FunPtr C_ActionEntryActivateFieldCallback)

-- | /No description available in the introspection data./
type ActionEntryActivateFieldCallback =
    Gio.SimpleAction.SimpleAction
    -> Maybe GVariant
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ActionEntryActivateFieldCallback`@.
noActionEntryActivateFieldCallback :: Maybe ActionEntryActivateFieldCallback
noActionEntryActivateFieldCallback :: Maybe ActionEntryActivateFieldCallback
noActionEntryActivateFieldCallback = Maybe ActionEntryActivateFieldCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type ActionEntryActivateFieldCallback_WithClosures =
    Gio.SimpleAction.SimpleAction
    -> Maybe GVariant
    -> Ptr ()
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ActionEntryActivateFieldCallback_WithClosures`@.
noActionEntryActivateFieldCallback_WithClosures :: Maybe ActionEntryActivateFieldCallback_WithClosures
noActionEntryActivateFieldCallback_WithClosures :: Maybe ActionEntryActivateFieldCallback_WithClosures
noActionEntryActivateFieldCallback_WithClosures = Maybe ActionEntryActivateFieldCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ActionEntryActivateFieldCallback :: ActionEntryActivateFieldCallback -> ActionEntryActivateFieldCallback_WithClosures
drop_closures_ActionEntryActivateFieldCallback :: ActionEntryActivateFieldCallback
-> ActionEntryActivateFieldCallback_WithClosures
drop_closures_ActionEntryActivateFieldCallback ActionEntryActivateFieldCallback
_f SimpleAction
action Maybe GVariant
parameter Ptr ()
_ = ActionEntryActivateFieldCallback
_f SimpleAction
action Maybe GVariant
parameter

-- | Wrap the callback into a `GClosure`.
genClosure_ActionEntryActivateFieldCallback :: MonadIO m => ActionEntryActivateFieldCallback -> m (GClosure C_ActionEntryActivateFieldCallback)
genClosure_ActionEntryActivateFieldCallback :: forall (m :: * -> *).
MonadIO m =>
ActionEntryActivateFieldCallback
-> m (GClosure C_ActionEntryChangeStateFieldCallback)
genClosure_ActionEntryActivateFieldCallback ActionEntryActivateFieldCallback
cb = IO (GClosure C_ActionEntryChangeStateFieldCallback)
-> m (GClosure C_ActionEntryChangeStateFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ActionEntryChangeStateFieldCallback)
 -> m (GClosure C_ActionEntryChangeStateFieldCallback))
-> IO (GClosure C_ActionEntryChangeStateFieldCallback)
-> m (GClosure C_ActionEntryChangeStateFieldCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: ActionEntryActivateFieldCallback_WithClosures
cb' = ActionEntryActivateFieldCallback
-> ActionEntryActivateFieldCallback_WithClosures
drop_closures_ActionEntryActivateFieldCallback ActionEntryActivateFieldCallback
cb
    let cb'' :: C_ActionEntryChangeStateFieldCallback
cb'' = Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
-> ActionEntryActivateFieldCallback_WithClosures
-> C_ActionEntryChangeStateFieldCallback
wrap_ActionEntryActivateFieldCallback Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
forall a. Maybe a
Nothing ActionEntryActivateFieldCallback_WithClosures
cb'
    C_ActionEntryChangeStateFieldCallback
-> IO (FunPtr C_ActionEntryChangeStateFieldCallback)
mk_ActionEntryActivateFieldCallback C_ActionEntryChangeStateFieldCallback
cb'' IO (FunPtr C_ActionEntryChangeStateFieldCallback)
-> (FunPtr C_ActionEntryChangeStateFieldCallback
    -> IO (GClosure C_ActionEntryChangeStateFieldCallback))
-> IO (GClosure C_ActionEntryChangeStateFieldCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ActionEntryChangeStateFieldCallback
-> IO (GClosure C_ActionEntryChangeStateFieldCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ActionEntryActivateFieldCallback` into a `C_ActionEntryActivateFieldCallback`.
wrap_ActionEntryActivateFieldCallback :: 
    Maybe (Ptr (FunPtr C_ActionEntryActivateFieldCallback)) ->
    ActionEntryActivateFieldCallback_WithClosures ->
    C_ActionEntryActivateFieldCallback
wrap_ActionEntryActivateFieldCallback :: Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
-> ActionEntryActivateFieldCallback_WithClosures
-> C_ActionEntryChangeStateFieldCallback
wrap_ActionEntryActivateFieldCallback Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback))
gi'funptrptr ActionEntryActivateFieldCallback_WithClosures
gi'cb Ptr SimpleAction
action Ptr GVariant
parameter Ptr ()
userData = do
    action' <- ((ManagedPtr SimpleAction -> SimpleAction)
-> Ptr SimpleAction -> IO SimpleAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SimpleAction -> SimpleAction
Gio.SimpleAction.SimpleAction) Ptr SimpleAction
action
    maybeParameter <-
        if parameter == FP.nullPtr
        then return Nothing
        else do
            parameter' <- B.GVariant.newGVariantFromPtr parameter
            return $ Just parameter'
    gi'cb  action' maybeParameter userData
    maybeReleaseFunPtr gi'funptrptr