-- | 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