module GI.Gio.Callbacks
(
ActionEntryActivateFieldCallback ,
ActionEntryActivateFieldCallbackC ,
actionEntryActivateFieldCallbackClosure ,
actionEntryActivateFieldCallbackWrapper ,
mkActionEntryActivateFieldCallback ,
noActionEntryActivateFieldCallback ,
ActionEntryChangeStateFieldCallback ,
ActionEntryChangeStateFieldCallbackC ,
actionEntryChangeStateFieldCallbackClosure,
actionEntryChangeStateFieldCallbackWrapper,
mkActionEntryChangeStateFieldCallback ,
noActionEntryChangeStateFieldCallback ,
AsyncReadyCallback ,
AsyncReadyCallbackC ,
asyncReadyCallbackClosure ,
asyncReadyCallbackWrapper ,
mkAsyncReadyCallback ,
noAsyncReadyCallback ,
BusAcquiredCallback ,
BusAcquiredCallbackC ,
busAcquiredCallbackClosure ,
busAcquiredCallbackWrapper ,
mkBusAcquiredCallback ,
noBusAcquiredCallback ,
BusNameAcquiredCallback ,
BusNameAcquiredCallbackC ,
busNameAcquiredCallbackClosure ,
busNameAcquiredCallbackWrapper ,
mkBusNameAcquiredCallback ,
noBusNameAcquiredCallback ,
BusNameAppearedCallback ,
BusNameAppearedCallbackC ,
busNameAppearedCallbackClosure ,
busNameAppearedCallbackWrapper ,
mkBusNameAppearedCallback ,
noBusNameAppearedCallback ,
BusNameLostCallback ,
BusNameLostCallbackC ,
busNameLostCallbackClosure ,
busNameLostCallbackWrapper ,
mkBusNameLostCallback ,
noBusNameLostCallback ,
BusNameVanishedCallback ,
BusNameVanishedCallbackC ,
busNameVanishedCallbackClosure ,
busNameVanishedCallbackWrapper ,
mkBusNameVanishedCallback ,
noBusNameVanishedCallback ,
CancellableSourceFunc ,
CancellableSourceFuncC ,
cancellableSourceFuncClosure ,
cancellableSourceFuncWrapper ,
mkCancellableSourceFunc ,
noCancellableSourceFunc ,
DBusInterfaceGetPropertyFunc ,
DBusInterfaceGetPropertyFuncC ,
dBusInterfaceGetPropertyFuncClosure ,
dBusInterfaceGetPropertyFuncWrapper ,
mkDBusInterfaceGetPropertyFunc ,
noDBusInterfaceGetPropertyFunc ,
DBusInterfaceMethodCallFunc ,
DBusInterfaceMethodCallFuncC ,
dBusInterfaceMethodCallFuncClosure ,
dBusInterfaceMethodCallFuncWrapper ,
mkDBusInterfaceMethodCallFunc ,
noDBusInterfaceMethodCallFunc ,
DBusInterfaceSetPropertyFunc ,
DBusInterfaceSetPropertyFuncC ,
dBusInterfaceSetPropertyFuncClosure ,
dBusInterfaceSetPropertyFuncWrapper ,
mkDBusInterfaceSetPropertyFunc ,
noDBusInterfaceSetPropertyFunc ,
DBusMessageFilterFunction ,
DBusMessageFilterFunctionC ,
dBusMessageFilterFunctionClosure ,
dBusMessageFilterFunctionWrapper ,
mkDBusMessageFilterFunction ,
noDBusMessageFilterFunction ,
DBusProxyTypeFunc ,
DBusProxyTypeFuncC ,
dBusProxyTypeFuncClosure ,
dBusProxyTypeFuncWrapper ,
mkDBusProxyTypeFunc ,
noDBusProxyTypeFunc ,
DBusSignalCallback ,
DBusSignalCallbackC ,
dBusSignalCallbackClosure ,
dBusSignalCallbackWrapper ,
mkDBusSignalCallback ,
noDBusSignalCallback ,
DBusSubtreeDispatchFunc ,
DBusSubtreeDispatchFuncC ,
dBusSubtreeDispatchFuncClosure ,
dBusSubtreeDispatchFuncWrapper ,
mkDBusSubtreeDispatchFunc ,
noDBusSubtreeDispatchFunc ,
DBusSubtreeIntrospectFunc ,
DBusSubtreeIntrospectFuncC ,
dBusSubtreeIntrospectFuncClosure ,
dBusSubtreeIntrospectFuncWrapper ,
mkDBusSubtreeIntrospectFunc ,
noDBusSubtreeIntrospectFunc ,
DesktopAppLaunchCallback ,
DesktopAppLaunchCallbackC ,
desktopAppLaunchCallbackClosure ,
desktopAppLaunchCallbackWrapper ,
mkDesktopAppLaunchCallback ,
noDesktopAppLaunchCallback ,
FileMeasureProgressCallback ,
FileMeasureProgressCallbackC ,
fileMeasureProgressCallbackClosure ,
fileMeasureProgressCallbackWrapper ,
mkFileMeasureProgressCallback ,
noFileMeasureProgressCallback ,
FileProgressCallback ,
FileProgressCallbackC ,
fileProgressCallbackClosure ,
fileProgressCallbackWrapper ,
mkFileProgressCallback ,
noFileProgressCallback ,
FileReadMoreCallback ,
FileReadMoreCallbackC ,
fileReadMoreCallbackClosure ,
fileReadMoreCallbackWrapper ,
mkFileReadMoreCallback ,
noFileReadMoreCallback ,
IOSchedulerJobFunc ,
IOSchedulerJobFuncC ,
iOSchedulerJobFuncClosure ,
iOSchedulerJobFuncWrapper ,
mkIOSchedulerJobFunc ,
noIOSchedulerJobFunc ,
PollableSourceFunc ,
PollableSourceFuncC ,
mkPollableSourceFunc ,
noPollableSourceFunc ,
pollableSourceFuncClosure ,
pollableSourceFuncWrapper ,
SettingsBindGetMapping ,
SettingsBindGetMappingC ,
mkSettingsBindGetMapping ,
noSettingsBindGetMapping ,
settingsBindGetMappingClosure ,
settingsBindGetMappingWrapper ,
SettingsBindSetMapping ,
SettingsBindSetMappingC ,
mkSettingsBindSetMapping ,
noSettingsBindSetMapping ,
settingsBindSetMappingClosure ,
settingsBindSetMappingWrapper ,
SettingsGetMapping ,
SettingsGetMappingC ,
mkSettingsGetMapping ,
noSettingsGetMapping ,
settingsGetMappingClosure ,
settingsGetMappingWrapper ,
SimpleAsyncThreadFunc ,
SimpleAsyncThreadFuncC ,
mkSimpleAsyncThreadFunc ,
noSimpleAsyncThreadFunc ,
simpleAsyncThreadFuncClosure ,
simpleAsyncThreadFuncWrapper ,
SocketSourceFunc ,
SocketSourceFuncC ,
mkSocketSourceFunc ,
noSocketSourceFunc ,
socketSourceFuncClosure ,
socketSourceFuncWrapper ,
TaskThreadFunc ,
TaskThreadFuncC ,
mkTaskThreadFunc ,
noTaskThreadFunc ,
taskThreadFuncClosure ,
taskThreadFuncWrapper ,
) where
import Prelude ()
import Data.GI.Base.ShortPrelude
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import GI.Gio.Types
import qualified GI.GLib as GLib
import qualified GI.GObject as GObject
taskThreadFuncClosure :: TaskThreadFunc -> IO Closure
taskThreadFuncClosure cb = newCClosure =<< mkTaskThreadFunc wrapped
where wrapped = taskThreadFuncWrapper Nothing cb
type TaskThreadFuncC =
Ptr Task ->
Ptr GObject.Object ->
Ptr () ->
Ptr Cancellable ->
IO ()
foreign import ccall "wrapper"
mkTaskThreadFunc :: TaskThreadFuncC -> IO (FunPtr TaskThreadFuncC)
type TaskThreadFunc =
Task ->
GObject.Object ->
Ptr () ->
Maybe Cancellable ->
IO ()
noTaskThreadFunc :: Maybe TaskThreadFunc
noTaskThreadFunc = Nothing
taskThreadFuncWrapper ::
Maybe (Ptr (FunPtr (TaskThreadFuncC))) ->
TaskThreadFunc ->
Ptr Task ->
Ptr GObject.Object ->
Ptr () ->
Ptr Cancellable ->
IO ()
taskThreadFuncWrapper funptrptr _cb task source_object task_data cancellable = do
task' <- (newObject Task) task
source_object' <- (newObject GObject.Object) source_object
maybeCancellable <-
if cancellable == nullPtr
then return Nothing
else do
cancellable' <- (newObject Cancellable) cancellable
return $ Just cancellable'
_cb task' source_object' task_data maybeCancellable
maybeReleaseFunPtr funptrptr
socketSourceFuncClosure :: SocketSourceFunc -> IO Closure
socketSourceFuncClosure cb = newCClosure =<< mkSocketSourceFunc wrapped
where wrapped = socketSourceFuncWrapper Nothing cb
type SocketSourceFuncC =
Ptr Socket ->
CUInt ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkSocketSourceFunc :: SocketSourceFuncC -> IO (FunPtr SocketSourceFuncC)
type SocketSourceFunc =
Socket ->
[GLib.IOCondition] ->
IO Bool
noSocketSourceFunc :: Maybe SocketSourceFunc
noSocketSourceFunc = Nothing
socketSourceFuncWrapper ::
Maybe (Ptr (FunPtr (SocketSourceFuncC))) ->
SocketSourceFunc ->
Ptr Socket ->
CUInt ->
Ptr () ->
IO CInt
socketSourceFuncWrapper funptrptr _cb socket condition _ = do
socket' <- (newObject Socket) socket
let condition' = wordToGFlags condition
result <- _cb socket' condition'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
simpleAsyncThreadFuncClosure :: SimpleAsyncThreadFunc -> IO Closure
simpleAsyncThreadFuncClosure cb = newCClosure =<< mkSimpleAsyncThreadFunc wrapped
where wrapped = simpleAsyncThreadFuncWrapper Nothing cb
type SimpleAsyncThreadFuncC =
Ptr SimpleAsyncResult ->
Ptr GObject.Object ->
Ptr Cancellable ->
IO ()
foreign import ccall "wrapper"
mkSimpleAsyncThreadFunc :: SimpleAsyncThreadFuncC -> IO (FunPtr SimpleAsyncThreadFuncC)
type SimpleAsyncThreadFunc =
SimpleAsyncResult ->
GObject.Object ->
Maybe Cancellable ->
IO ()
noSimpleAsyncThreadFunc :: Maybe SimpleAsyncThreadFunc
noSimpleAsyncThreadFunc = Nothing
simpleAsyncThreadFuncWrapper ::
Maybe (Ptr (FunPtr (SimpleAsyncThreadFuncC))) ->
SimpleAsyncThreadFunc ->
Ptr SimpleAsyncResult ->
Ptr GObject.Object ->
Ptr Cancellable ->
IO ()
simpleAsyncThreadFuncWrapper funptrptr _cb res object cancellable = do
res' <- (newObject SimpleAsyncResult) res
object' <- (newObject GObject.Object) object
maybeCancellable <-
if cancellable == nullPtr
then return Nothing
else do
cancellable' <- (newObject Cancellable) cancellable
return $ Just cancellable'
_cb res' object' maybeCancellable
maybeReleaseFunPtr funptrptr
settingsGetMappingClosure :: SettingsGetMapping -> IO Closure
settingsGetMappingClosure cb = newCClosure =<< mkSettingsGetMapping wrapped
where wrapped = settingsGetMappingWrapper Nothing cb
type SettingsGetMappingC =
Ptr GVariant ->
Ptr (Ptr ()) ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkSettingsGetMapping :: SettingsGetMappingC -> IO (FunPtr SettingsGetMappingC)
type SettingsGetMapping =
GVariant ->
IO (Bool,(Ptr ()))
noSettingsGetMapping :: Maybe SettingsGetMapping
noSettingsGetMapping = Nothing
settingsGetMappingWrapper ::
Maybe (Ptr (FunPtr (SettingsGetMappingC))) ->
SettingsGetMapping ->
Ptr GVariant ->
Ptr (Ptr ()) ->
Ptr () ->
IO CInt
settingsGetMappingWrapper funptrptr _cb value result_ _ = do
value' <- newGVariantFromPtr value
(result, outresult_) <- _cb value'
poke result_ outresult_
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
settingsBindSetMappingClosure :: SettingsBindSetMapping -> IO Closure
settingsBindSetMappingClosure cb = newCClosure =<< mkSettingsBindSetMapping wrapped
where wrapped = settingsBindSetMappingWrapper Nothing cb
type SettingsBindSetMappingC =
Ptr GValue ->
Ptr GLib.VariantType ->
Ptr () ->
IO (Ptr GVariant)
foreign import ccall "wrapper"
mkSettingsBindSetMapping :: SettingsBindSetMappingC -> IO (FunPtr SettingsBindSetMappingC)
type SettingsBindSetMapping =
GValue ->
GLib.VariantType ->
IO GVariant
noSettingsBindSetMapping :: Maybe SettingsBindSetMapping
noSettingsBindSetMapping = Nothing
settingsBindSetMappingWrapper ::
Maybe (Ptr (FunPtr (SettingsBindSetMappingC))) ->
SettingsBindSetMapping ->
Ptr GValue ->
Ptr GLib.VariantType ->
Ptr () ->
IO (Ptr GVariant)
settingsBindSetMappingWrapper funptrptr _cb value expected_type _ = do
value' <- (newBoxed GValue) value
expected_type' <- (newBoxed GLib.VariantType) expected_type
result <- _cb value' expected_type'
maybeReleaseFunPtr funptrptr
result' <- refGVariant result
return result'
settingsBindGetMappingClosure :: SettingsBindGetMapping -> IO Closure
settingsBindGetMappingClosure cb = newCClosure =<< mkSettingsBindGetMapping wrapped
where wrapped = settingsBindGetMappingWrapper Nothing cb
type SettingsBindGetMappingC =
Ptr GValue ->
Ptr GVariant ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkSettingsBindGetMapping :: SettingsBindGetMappingC -> IO (FunPtr SettingsBindGetMappingC)
type SettingsBindGetMapping =
GValue ->
GVariant ->
IO Bool
noSettingsBindGetMapping :: Maybe SettingsBindGetMapping
noSettingsBindGetMapping = Nothing
settingsBindGetMappingWrapper ::
Maybe (Ptr (FunPtr (SettingsBindGetMappingC))) ->
SettingsBindGetMapping ->
Ptr GValue ->
Ptr GVariant ->
Ptr () ->
IO CInt
settingsBindGetMappingWrapper funptrptr _cb value variant _ = do
value' <- (newBoxed GValue) value
variant' <- newGVariantFromPtr variant
result <- _cb value' variant'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
pollableSourceFuncClosure :: PollableSourceFunc -> IO Closure
pollableSourceFuncClosure cb = newCClosure =<< mkPollableSourceFunc wrapped
where wrapped = pollableSourceFuncWrapper Nothing cb
type PollableSourceFuncC =
Ptr GObject.Object ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkPollableSourceFunc :: PollableSourceFuncC -> IO (FunPtr PollableSourceFuncC)
type PollableSourceFunc =
GObject.Object ->
IO Bool
noPollableSourceFunc :: Maybe PollableSourceFunc
noPollableSourceFunc = Nothing
pollableSourceFuncWrapper ::
Maybe (Ptr (FunPtr (PollableSourceFuncC))) ->
PollableSourceFunc ->
Ptr GObject.Object ->
Ptr () ->
IO CInt
pollableSourceFuncWrapper funptrptr _cb pollable_stream _ = do
pollable_stream' <- (newObject GObject.Object) pollable_stream
result <- _cb pollable_stream'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
iOSchedulerJobFuncClosure :: IOSchedulerJobFunc -> IO Closure
iOSchedulerJobFuncClosure cb = newCClosure =<< mkIOSchedulerJobFunc wrapped
where wrapped = iOSchedulerJobFuncWrapper Nothing cb
type IOSchedulerJobFuncC =
Ptr IOSchedulerJob ->
Ptr Cancellable ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkIOSchedulerJobFunc :: IOSchedulerJobFuncC -> IO (FunPtr IOSchedulerJobFuncC)
type IOSchedulerJobFunc =
IOSchedulerJob ->
Maybe Cancellable ->
IO Bool
noIOSchedulerJobFunc :: Maybe IOSchedulerJobFunc
noIOSchedulerJobFunc = Nothing
iOSchedulerJobFuncWrapper ::
Maybe (Ptr (FunPtr (IOSchedulerJobFuncC))) ->
IOSchedulerJobFunc ->
Ptr IOSchedulerJob ->
Ptr Cancellable ->
Ptr () ->
IO CInt
iOSchedulerJobFuncWrapper funptrptr _cb job cancellable _ = do
job' <- (\x -> IOSchedulerJob <$> newForeignPtr_ x) job
maybeCancellable <-
if cancellable == nullPtr
then return Nothing
else do
cancellable' <- (newObject Cancellable) cancellable
return $ Just cancellable'
result <- _cb job' maybeCancellable
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
fileReadMoreCallbackClosure :: FileReadMoreCallback -> IO Closure
fileReadMoreCallbackClosure cb = newCClosure =<< mkFileReadMoreCallback wrapped
where wrapped = fileReadMoreCallbackWrapper Nothing cb
type FileReadMoreCallbackC =
CString ->
Int64 ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkFileReadMoreCallback :: FileReadMoreCallbackC -> IO (FunPtr FileReadMoreCallbackC)
type FileReadMoreCallback =
T.Text ->
Int64 ->
Ptr () ->
IO Bool
noFileReadMoreCallback :: Maybe FileReadMoreCallback
noFileReadMoreCallback = Nothing
fileReadMoreCallbackWrapper ::
Maybe (Ptr (FunPtr (FileReadMoreCallbackC))) ->
FileReadMoreCallback ->
CString ->
Int64 ->
Ptr () ->
IO CInt
fileReadMoreCallbackWrapper funptrptr _cb file_contents file_size callback_data = do
file_contents' <- cstringToText file_contents
result <- _cb file_contents' file_size callback_data
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
fileProgressCallbackClosure :: FileProgressCallback -> IO Closure
fileProgressCallbackClosure cb = newCClosure =<< mkFileProgressCallback wrapped
where wrapped = fileProgressCallbackWrapper Nothing cb
type FileProgressCallbackC =
Int64 ->
Int64 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkFileProgressCallback :: FileProgressCallbackC -> IO (FunPtr FileProgressCallbackC)
type FileProgressCallback =
Int64 ->
Int64 ->
IO ()
noFileProgressCallback :: Maybe FileProgressCallback
noFileProgressCallback = Nothing
fileProgressCallbackWrapper ::
Maybe (Ptr (FunPtr (FileProgressCallbackC))) ->
FileProgressCallback ->
Int64 ->
Int64 ->
Ptr () ->
IO ()
fileProgressCallbackWrapper funptrptr _cb current_num_bytes total_num_bytes _ = do
_cb current_num_bytes total_num_bytes
maybeReleaseFunPtr funptrptr
fileMeasureProgressCallbackClosure :: FileMeasureProgressCallback -> IO Closure
fileMeasureProgressCallbackClosure cb = newCClosure =<< mkFileMeasureProgressCallback wrapped
where wrapped = fileMeasureProgressCallbackWrapper Nothing cb
type FileMeasureProgressCallbackC =
CInt ->
Word64 ->
Word64 ->
Word64 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkFileMeasureProgressCallback :: FileMeasureProgressCallbackC -> IO (FunPtr FileMeasureProgressCallbackC)
type FileMeasureProgressCallback =
Bool ->
Word64 ->
Word64 ->
Word64 ->
IO ()
noFileMeasureProgressCallback :: Maybe FileMeasureProgressCallback
noFileMeasureProgressCallback = Nothing
fileMeasureProgressCallbackWrapper ::
Maybe (Ptr (FunPtr (FileMeasureProgressCallbackC))) ->
FileMeasureProgressCallback ->
CInt ->
Word64 ->
Word64 ->
Word64 ->
Ptr () ->
IO ()
fileMeasureProgressCallbackWrapper funptrptr _cb reporting current_size num_dirs num_files _ = do
let reporting' = (/= 0) reporting
_cb reporting' current_size num_dirs num_files
maybeReleaseFunPtr funptrptr
desktopAppLaunchCallbackClosure :: DesktopAppLaunchCallback -> IO Closure
desktopAppLaunchCallbackClosure cb = newCClosure =<< mkDesktopAppLaunchCallback wrapped
where wrapped = desktopAppLaunchCallbackWrapper Nothing cb
type DesktopAppLaunchCallbackC =
Ptr DesktopAppInfo ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkDesktopAppLaunchCallback :: DesktopAppLaunchCallbackC -> IO (FunPtr DesktopAppLaunchCallbackC)
type DesktopAppLaunchCallback =
DesktopAppInfo ->
Int32 ->
IO ()
noDesktopAppLaunchCallback :: Maybe DesktopAppLaunchCallback
noDesktopAppLaunchCallback = Nothing
desktopAppLaunchCallbackWrapper ::
Maybe (Ptr (FunPtr (DesktopAppLaunchCallbackC))) ->
DesktopAppLaunchCallback ->
Ptr DesktopAppInfo ->
Int32 ->
Ptr () ->
IO ()
desktopAppLaunchCallbackWrapper funptrptr _cb appinfo pid _ = do
appinfo' <- (newObject DesktopAppInfo) appinfo
_cb appinfo' pid
maybeReleaseFunPtr funptrptr
dBusSubtreeIntrospectFuncClosure :: DBusSubtreeIntrospectFunc -> IO Closure
dBusSubtreeIntrospectFuncClosure cb = newCClosure =<< mkDBusSubtreeIntrospectFunc wrapped
where wrapped = dBusSubtreeIntrospectFuncWrapper Nothing cb
type DBusSubtreeIntrospectFuncC =
Ptr DBusConnection ->
CString ->
CString ->
CString ->
Ptr () ->
IO (Ptr DBusInterfaceInfo)
foreign import ccall "wrapper"
mkDBusSubtreeIntrospectFunc :: DBusSubtreeIntrospectFuncC -> IO (FunPtr DBusSubtreeIntrospectFuncC)
type DBusSubtreeIntrospectFunc =
DBusConnection ->
T.Text ->
T.Text ->
T.Text ->
IO DBusInterfaceInfo
noDBusSubtreeIntrospectFunc :: Maybe DBusSubtreeIntrospectFunc
noDBusSubtreeIntrospectFunc = Nothing
dBusSubtreeIntrospectFuncWrapper ::
Maybe (Ptr (FunPtr (DBusSubtreeIntrospectFuncC))) ->
DBusSubtreeIntrospectFunc ->
Ptr DBusConnection ->
CString ->
CString ->
CString ->
Ptr () ->
IO (Ptr DBusInterfaceInfo)
dBusSubtreeIntrospectFuncWrapper funptrptr _cb connection sender object_path node _ = do
connection' <- (newObject DBusConnection) connection
sender' <- cstringToText sender
object_path' <- cstringToText object_path
node' <- cstringToText node
result <- _cb connection' sender' object_path' node'
maybeReleaseFunPtr funptrptr
result' <- copyBoxed result
return result'
dBusSubtreeDispatchFuncClosure :: DBusSubtreeDispatchFunc -> IO Closure
dBusSubtreeDispatchFuncClosure cb = newCClosure =<< mkDBusSubtreeDispatchFunc wrapped
where wrapped = dBusSubtreeDispatchFuncWrapper Nothing cb
type DBusSubtreeDispatchFuncC =
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr () ->
Ptr () ->
IO (Ptr DBusInterfaceVTable)
foreign import ccall "wrapper"
mkDBusSubtreeDispatchFunc :: DBusSubtreeDispatchFuncC -> IO (FunPtr DBusSubtreeDispatchFuncC)
type DBusSubtreeDispatchFunc =
DBusConnection ->
T.Text ->
T.Text ->
T.Text ->
T.Text ->
Ptr () ->
IO DBusInterfaceVTable
noDBusSubtreeDispatchFunc :: Maybe DBusSubtreeDispatchFunc
noDBusSubtreeDispatchFunc = Nothing
dBusSubtreeDispatchFuncWrapper ::
Maybe (Ptr (FunPtr (DBusSubtreeDispatchFuncC))) ->
DBusSubtreeDispatchFunc ->
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr () ->
Ptr () ->
IO (Ptr DBusInterfaceVTable)
dBusSubtreeDispatchFuncWrapper funptrptr _cb connection sender object_path interface_name node out_user_data _ = do
connection' <- (newObject DBusConnection) connection
sender' <- cstringToText sender
object_path' <- cstringToText object_path
interface_name' <- cstringToText interface_name
node' <- cstringToText node
result <- _cb connection' sender' object_path' interface_name' node' out_user_data
maybeReleaseFunPtr funptrptr
let result' = unsafeManagedPtrGetPtr result
return result'
dBusSignalCallbackClosure :: DBusSignalCallback -> IO Closure
dBusSignalCallbackClosure cb = newCClosure =<< mkDBusSignalCallback wrapped
where wrapped = dBusSignalCallbackWrapper Nothing cb
type DBusSignalCallbackC =
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GVariant ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkDBusSignalCallback :: DBusSignalCallbackC -> IO (FunPtr DBusSignalCallbackC)
type DBusSignalCallback =
DBusConnection ->
T.Text ->
T.Text ->
T.Text ->
T.Text ->
GVariant ->
IO ()
noDBusSignalCallback :: Maybe DBusSignalCallback
noDBusSignalCallback = Nothing
dBusSignalCallbackWrapper ::
Maybe (Ptr (FunPtr (DBusSignalCallbackC))) ->
DBusSignalCallback ->
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GVariant ->
Ptr () ->
IO ()
dBusSignalCallbackWrapper funptrptr _cb connection sender_name object_path interface_name signal_name parameters _ = do
connection' <- (newObject DBusConnection) connection
sender_name' <- cstringToText sender_name
object_path' <- cstringToText object_path
interface_name' <- cstringToText interface_name
signal_name' <- cstringToText signal_name
parameters' <- newGVariantFromPtr parameters
_cb connection' sender_name' object_path' interface_name' signal_name' parameters'
maybeReleaseFunPtr funptrptr
dBusProxyTypeFuncClosure :: DBusProxyTypeFunc -> IO Closure
dBusProxyTypeFuncClosure cb = newCClosure =<< mkDBusProxyTypeFunc wrapped
where wrapped = dBusProxyTypeFuncWrapper Nothing cb
type DBusProxyTypeFuncC =
Ptr DBusObjectManagerClient ->
CString ->
CString ->
Ptr () ->
IO CGType
foreign import ccall "wrapper"
mkDBusProxyTypeFunc :: DBusProxyTypeFuncC -> IO (FunPtr DBusProxyTypeFuncC)
type DBusProxyTypeFunc =
DBusObjectManagerClient ->
T.Text ->
Maybe T.Text ->
IO GType
noDBusProxyTypeFunc :: Maybe DBusProxyTypeFunc
noDBusProxyTypeFunc = Nothing
dBusProxyTypeFuncWrapper ::
Maybe (Ptr (FunPtr (DBusProxyTypeFuncC))) ->
DBusProxyTypeFunc ->
Ptr DBusObjectManagerClient ->
CString ->
CString ->
Ptr () ->
IO CGType
dBusProxyTypeFuncWrapper funptrptr _cb manager object_path interface_name _ = do
manager' <- (newObject DBusObjectManagerClient) manager
object_path' <- cstringToText object_path
maybeInterface_name <-
if interface_name == nullPtr
then return Nothing
else do
interface_name' <- cstringToText interface_name
return $ Just interface_name'
result <- _cb manager' object_path' maybeInterface_name
maybeReleaseFunPtr funptrptr
let result' = gtypeToCGType result
return result'
dBusMessageFilterFunctionClosure :: DBusMessageFilterFunction -> IO Closure
dBusMessageFilterFunctionClosure cb = newCClosure =<< mkDBusMessageFilterFunction wrapped
where wrapped = dBusMessageFilterFunctionWrapper Nothing cb
type DBusMessageFilterFunctionC =
Ptr DBusConnection ->
Ptr DBusMessage ->
CInt ->
Ptr () ->
IO (Ptr DBusMessage)
foreign import ccall "wrapper"
mkDBusMessageFilterFunction :: DBusMessageFilterFunctionC -> IO (FunPtr DBusMessageFilterFunctionC)
type DBusMessageFilterFunction =
DBusConnection ->
DBusMessage ->
Bool ->
IO DBusMessage
noDBusMessageFilterFunction :: Maybe DBusMessageFilterFunction
noDBusMessageFilterFunction = Nothing
dBusMessageFilterFunctionWrapper ::
Maybe (Ptr (FunPtr (DBusMessageFilterFunctionC))) ->
DBusMessageFilterFunction ->
Ptr DBusConnection ->
Ptr DBusMessage ->
CInt ->
Ptr () ->
IO (Ptr DBusMessage)
dBusMessageFilterFunctionWrapper funptrptr _cb connection message incoming _ = do
connection' <- (newObject DBusConnection) connection
message' <- (wrapObject DBusMessage) message
let incoming' = (/= 0) incoming
result <- _cb connection' message' incoming'
maybeReleaseFunPtr funptrptr
result' <- refObject result
return result'
dBusInterfaceSetPropertyFuncClosure :: DBusInterfaceSetPropertyFunc -> IO Closure
dBusInterfaceSetPropertyFuncClosure cb = newCClosure =<< mkDBusInterfaceSetPropertyFunc wrapped
where wrapped = dBusInterfaceSetPropertyFuncWrapper Nothing cb
type DBusInterfaceSetPropertyFuncC =
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GVariant ->
Ptr GError ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkDBusInterfaceSetPropertyFunc :: DBusInterfaceSetPropertyFuncC -> IO (FunPtr DBusInterfaceSetPropertyFuncC)
type DBusInterfaceSetPropertyFunc =
DBusConnection ->
T.Text ->
T.Text ->
T.Text ->
T.Text ->
GVariant ->
GError ->
IO Bool
noDBusInterfaceSetPropertyFunc :: Maybe DBusInterfaceSetPropertyFunc
noDBusInterfaceSetPropertyFunc = Nothing
dBusInterfaceSetPropertyFuncWrapper ::
Maybe (Ptr (FunPtr (DBusInterfaceSetPropertyFuncC))) ->
DBusInterfaceSetPropertyFunc ->
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GVariant ->
Ptr GError ->
Ptr () ->
IO CInt
dBusInterfaceSetPropertyFuncWrapper funptrptr _cb connection sender object_path interface_name property_name value error_ _ = do
connection' <- (newObject DBusConnection) connection
sender' <- cstringToText sender
object_path' <- cstringToText object_path
interface_name' <- cstringToText interface_name
property_name' <- cstringToText property_name
value' <- newGVariantFromPtr value
error_' <- (newBoxed GError) error_
result <- _cb connection' sender' object_path' interface_name' property_name' value' error_'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
dBusInterfaceMethodCallFuncClosure :: DBusInterfaceMethodCallFunc -> IO Closure
dBusInterfaceMethodCallFuncClosure cb = newCClosure =<< mkDBusInterfaceMethodCallFunc wrapped
where wrapped = dBusInterfaceMethodCallFuncWrapper Nothing cb
type DBusInterfaceMethodCallFuncC =
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GVariant ->
Ptr DBusMethodInvocation ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkDBusInterfaceMethodCallFunc :: DBusInterfaceMethodCallFuncC -> IO (FunPtr DBusInterfaceMethodCallFuncC)
type DBusInterfaceMethodCallFunc =
DBusConnection ->
T.Text ->
T.Text ->
T.Text ->
T.Text ->
GVariant ->
DBusMethodInvocation ->
IO ()
noDBusInterfaceMethodCallFunc :: Maybe DBusInterfaceMethodCallFunc
noDBusInterfaceMethodCallFunc = Nothing
dBusInterfaceMethodCallFuncWrapper ::
Maybe (Ptr (FunPtr (DBusInterfaceMethodCallFuncC))) ->
DBusInterfaceMethodCallFunc ->
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GVariant ->
Ptr DBusMethodInvocation ->
Ptr () ->
IO ()
dBusInterfaceMethodCallFuncWrapper funptrptr _cb connection sender object_path interface_name method_name parameters invocation _ = do
connection' <- (newObject DBusConnection) connection
sender' <- cstringToText sender
object_path' <- cstringToText object_path
interface_name' <- cstringToText interface_name
method_name' <- cstringToText method_name
parameters' <- newGVariantFromPtr parameters
invocation' <- (wrapObject DBusMethodInvocation) invocation
_cb connection' sender' object_path' interface_name' method_name' parameters' invocation'
maybeReleaseFunPtr funptrptr
dBusInterfaceGetPropertyFuncClosure :: DBusInterfaceGetPropertyFunc -> IO Closure
dBusInterfaceGetPropertyFuncClosure cb = newCClosure =<< mkDBusInterfaceGetPropertyFunc wrapped
where wrapped = dBusInterfaceGetPropertyFuncWrapper Nothing cb
type DBusInterfaceGetPropertyFuncC =
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GError ->
Ptr () ->
IO (Ptr GVariant)
foreign import ccall "wrapper"
mkDBusInterfaceGetPropertyFunc :: DBusInterfaceGetPropertyFuncC -> IO (FunPtr DBusInterfaceGetPropertyFuncC)
type DBusInterfaceGetPropertyFunc =
DBusConnection ->
T.Text ->
T.Text ->
T.Text ->
T.Text ->
GError ->
IO GVariant
noDBusInterfaceGetPropertyFunc :: Maybe DBusInterfaceGetPropertyFunc
noDBusInterfaceGetPropertyFunc = Nothing
dBusInterfaceGetPropertyFuncWrapper ::
Maybe (Ptr (FunPtr (DBusInterfaceGetPropertyFuncC))) ->
DBusInterfaceGetPropertyFunc ->
Ptr DBusConnection ->
CString ->
CString ->
CString ->
CString ->
Ptr GError ->
Ptr () ->
IO (Ptr GVariant)
dBusInterfaceGetPropertyFuncWrapper funptrptr _cb connection sender object_path interface_name property_name error_ _ = do
connection' <- (newObject DBusConnection) connection
sender' <- cstringToText sender
object_path' <- cstringToText object_path
interface_name' <- cstringToText interface_name
property_name' <- cstringToText property_name
error_' <- (newBoxed GError) error_
result <- _cb connection' sender' object_path' interface_name' property_name' error_'
maybeReleaseFunPtr funptrptr
result' <- refGVariant result
return result'
cancellableSourceFuncClosure :: CancellableSourceFunc -> IO Closure
cancellableSourceFuncClosure cb = newCClosure =<< mkCancellableSourceFunc wrapped
where wrapped = cancellableSourceFuncWrapper Nothing cb
type CancellableSourceFuncC =
Ptr Cancellable ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkCancellableSourceFunc :: CancellableSourceFuncC -> IO (FunPtr CancellableSourceFuncC)
type CancellableSourceFunc =
Maybe Cancellable ->
IO Bool
noCancellableSourceFunc :: Maybe CancellableSourceFunc
noCancellableSourceFunc = Nothing
cancellableSourceFuncWrapper ::
Maybe (Ptr (FunPtr (CancellableSourceFuncC))) ->
CancellableSourceFunc ->
Ptr Cancellable ->
Ptr () ->
IO CInt
cancellableSourceFuncWrapper funptrptr _cb cancellable _ = do
maybeCancellable <-
if cancellable == nullPtr
then return Nothing
else do
cancellable' <- (newObject Cancellable) cancellable
return $ Just cancellable'
result <- _cb maybeCancellable
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
busNameVanishedCallbackClosure :: BusNameVanishedCallback -> IO Closure
busNameVanishedCallbackClosure cb = newCClosure =<< mkBusNameVanishedCallback wrapped
where wrapped = busNameVanishedCallbackWrapper Nothing cb
type BusNameVanishedCallbackC =
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBusNameVanishedCallback :: BusNameVanishedCallbackC -> IO (FunPtr BusNameVanishedCallbackC)
type BusNameVanishedCallback =
DBusConnection ->
T.Text ->
IO ()
noBusNameVanishedCallback :: Maybe BusNameVanishedCallback
noBusNameVanishedCallback = Nothing
busNameVanishedCallbackWrapper ::
Maybe (Ptr (FunPtr (BusNameVanishedCallbackC))) ->
BusNameVanishedCallback ->
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
busNameVanishedCallbackWrapper funptrptr _cb connection name _ = do
connection' <- (newObject DBusConnection) connection
name' <- cstringToText name
_cb connection' name'
maybeReleaseFunPtr funptrptr
busNameLostCallbackClosure :: BusNameLostCallback -> IO Closure
busNameLostCallbackClosure cb = newCClosure =<< mkBusNameLostCallback wrapped
where wrapped = busNameLostCallbackWrapper Nothing cb
type BusNameLostCallbackC =
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBusNameLostCallback :: BusNameLostCallbackC -> IO (FunPtr BusNameLostCallbackC)
type BusNameLostCallback =
DBusConnection ->
T.Text ->
IO ()
noBusNameLostCallback :: Maybe BusNameLostCallback
noBusNameLostCallback = Nothing
busNameLostCallbackWrapper ::
Maybe (Ptr (FunPtr (BusNameLostCallbackC))) ->
BusNameLostCallback ->
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
busNameLostCallbackWrapper funptrptr _cb connection name _ = do
connection' <- (newObject DBusConnection) connection
name' <- cstringToText name
_cb connection' name'
maybeReleaseFunPtr funptrptr
busNameAppearedCallbackClosure :: BusNameAppearedCallback -> IO Closure
busNameAppearedCallbackClosure cb = newCClosure =<< mkBusNameAppearedCallback wrapped
where wrapped = busNameAppearedCallbackWrapper Nothing cb
type BusNameAppearedCallbackC =
Ptr DBusConnection ->
CString ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBusNameAppearedCallback :: BusNameAppearedCallbackC -> IO (FunPtr BusNameAppearedCallbackC)
type BusNameAppearedCallback =
DBusConnection ->
T.Text ->
T.Text ->
IO ()
noBusNameAppearedCallback :: Maybe BusNameAppearedCallback
noBusNameAppearedCallback = Nothing
busNameAppearedCallbackWrapper ::
Maybe (Ptr (FunPtr (BusNameAppearedCallbackC))) ->
BusNameAppearedCallback ->
Ptr DBusConnection ->
CString ->
CString ->
Ptr () ->
IO ()
busNameAppearedCallbackWrapper funptrptr _cb connection name name_owner _ = do
connection' <- (newObject DBusConnection) connection
name' <- cstringToText name
name_owner' <- cstringToText name_owner
_cb connection' name' name_owner'
maybeReleaseFunPtr funptrptr
busNameAcquiredCallbackClosure :: BusNameAcquiredCallback -> IO Closure
busNameAcquiredCallbackClosure cb = newCClosure =<< mkBusNameAcquiredCallback wrapped
where wrapped = busNameAcquiredCallbackWrapper Nothing cb
type BusNameAcquiredCallbackC =
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBusNameAcquiredCallback :: BusNameAcquiredCallbackC -> IO (FunPtr BusNameAcquiredCallbackC)
type BusNameAcquiredCallback =
DBusConnection ->
T.Text ->
IO ()
noBusNameAcquiredCallback :: Maybe BusNameAcquiredCallback
noBusNameAcquiredCallback = Nothing
busNameAcquiredCallbackWrapper ::
Maybe (Ptr (FunPtr (BusNameAcquiredCallbackC))) ->
BusNameAcquiredCallback ->
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
busNameAcquiredCallbackWrapper funptrptr _cb connection name _ = do
connection' <- (newObject DBusConnection) connection
name' <- cstringToText name
_cb connection' name'
maybeReleaseFunPtr funptrptr
busAcquiredCallbackClosure :: BusAcquiredCallback -> IO Closure
busAcquiredCallbackClosure cb = newCClosure =<< mkBusAcquiredCallback wrapped
where wrapped = busAcquiredCallbackWrapper Nothing cb
type BusAcquiredCallbackC =
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBusAcquiredCallback :: BusAcquiredCallbackC -> IO (FunPtr BusAcquiredCallbackC)
type BusAcquiredCallback =
DBusConnection ->
T.Text ->
IO ()
noBusAcquiredCallback :: Maybe BusAcquiredCallback
noBusAcquiredCallback = Nothing
busAcquiredCallbackWrapper ::
Maybe (Ptr (FunPtr (BusAcquiredCallbackC))) ->
BusAcquiredCallback ->
Ptr DBusConnection ->
CString ->
Ptr () ->
IO ()
busAcquiredCallbackWrapper funptrptr _cb connection name _ = do
connection' <- (newObject DBusConnection) connection
name' <- cstringToText name
_cb connection' name'
maybeReleaseFunPtr funptrptr
asyncReadyCallbackClosure :: AsyncReadyCallback -> IO Closure
asyncReadyCallbackClosure cb = newCClosure =<< mkAsyncReadyCallback wrapped
where wrapped = asyncReadyCallbackWrapper Nothing cb
type AsyncReadyCallbackC =
Ptr GObject.Object ->
Ptr AsyncResult ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkAsyncReadyCallback :: AsyncReadyCallbackC -> IO (FunPtr AsyncReadyCallbackC)
type AsyncReadyCallback =
GObject.Object ->
AsyncResult ->
IO ()
noAsyncReadyCallback :: Maybe AsyncReadyCallback
noAsyncReadyCallback = Nothing
asyncReadyCallbackWrapper ::
Maybe (Ptr (FunPtr (AsyncReadyCallbackC))) ->
AsyncReadyCallback ->
Ptr GObject.Object ->
Ptr AsyncResult ->
Ptr () ->
IO ()
asyncReadyCallbackWrapper funptrptr _cb source_object res _ = do
source_object' <- (newObject GObject.Object) source_object
res' <- (newObject AsyncResult) res
_cb source_object' res'
maybeReleaseFunPtr funptrptr
actionEntryChangeStateFieldCallbackClosure :: ActionEntryChangeStateFieldCallback -> IO Closure
actionEntryChangeStateFieldCallbackClosure cb = newCClosure =<< mkActionEntryChangeStateFieldCallback wrapped
where wrapped = actionEntryChangeStateFieldCallbackWrapper Nothing cb
type ActionEntryChangeStateFieldCallbackC =
Ptr SimpleAction ->
Ptr GVariant ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkActionEntryChangeStateFieldCallback :: ActionEntryChangeStateFieldCallbackC -> IO (FunPtr ActionEntryChangeStateFieldCallbackC)
type ActionEntryChangeStateFieldCallback =
SimpleAction ->
GVariant ->
IO ()
noActionEntryChangeStateFieldCallback :: Maybe ActionEntryChangeStateFieldCallback
noActionEntryChangeStateFieldCallback = Nothing
actionEntryChangeStateFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ActionEntryChangeStateFieldCallbackC))) ->
ActionEntryChangeStateFieldCallback ->
Ptr SimpleAction ->
Ptr GVariant ->
Ptr () ->
IO ()
actionEntryChangeStateFieldCallbackWrapper funptrptr _cb action value _ = do
action' <- (newObject SimpleAction) action
value' <- newGVariantFromPtr value
_cb action' value'
maybeReleaseFunPtr funptrptr
actionEntryActivateFieldCallbackClosure :: ActionEntryActivateFieldCallback -> IO Closure
actionEntryActivateFieldCallbackClosure cb = newCClosure =<< mkActionEntryActivateFieldCallback wrapped
where wrapped = actionEntryActivateFieldCallbackWrapper Nothing cb
type ActionEntryActivateFieldCallbackC =
Ptr SimpleAction ->
Ptr GVariant ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkActionEntryActivateFieldCallback :: ActionEntryActivateFieldCallbackC -> IO (FunPtr ActionEntryActivateFieldCallbackC)
type ActionEntryActivateFieldCallback =
SimpleAction ->
GVariant ->
IO ()
noActionEntryActivateFieldCallback :: Maybe ActionEntryActivateFieldCallback
noActionEntryActivateFieldCallback = Nothing
actionEntryActivateFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ActionEntryActivateFieldCallbackC))) ->
ActionEntryActivateFieldCallback ->
Ptr SimpleAction ->
Ptr GVariant ->
Ptr () ->
IO ()
actionEntryActivateFieldCallbackWrapper funptrptr _cb action parameter _ = do
action' <- (newObject SimpleAction) action
parameter' <- newGVariantFromPtr parameter
_cb action' parameter'
maybeReleaseFunPtr funptrptr