GI.NM.Callbacks

Signals

KeyfileReadHandler

type C_KeyfileReadHandler = Ptr KeyFile -> Ptr Connection -> CUInt -> Ptr KeyfileHandlerData -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type KeyfileReadHandler

Arguments

 = KeyFile

keyfile: the KeyFile that is currently read

-> Connection

connection: the Connection that is being constructed.

-> KeyfileHandlerType

handlerType: the NMKeyfileHandlerType that indicates which type the request is.

-> KeyfileHandlerData

handlerData: the KeyfileHandlerData. What you can do with it depends on the handlerType.

-> IO Bool

Returns: the callee should return TRUE, if the event was handled and/or recognized. Otherwise, a default action will be performed that depends on the type. For KeyfileHandlerTypeWarn type, the default action is doing nothing.

Hook to keyfileRead.

The callee may abort the reading by setting an error via keyfileHandlerDataFailWithError.

Since: 1.30

type KeyfileReadHandler_WithClosures

Arguments

 = KeyFile

keyfile: the KeyFile that is currently read

-> Connection

connection: the Connection that is being constructed.

-> KeyfileHandlerType

handlerType: the NMKeyfileHandlerType that indicates which type the request is.

-> KeyfileHandlerData

handlerData: the KeyfileHandlerData. What you can do with it depends on the handlerType.

-> Ptr ()

userData: the user-data argument to keyfileRead.

-> IO Bool

Returns: the callee should return TRUE, if the event was handled and/or recognized. Otherwise, a default action will be performed that depends on the type. For KeyfileHandlerTypeWarn type, the default action is doing nothing.

Hook to keyfileRead.

The callee may abort the reading by setting an error via keyfileHandlerDataFailWithError.

Since: 1.30

drop_closures_KeyfileReadHandler :: KeyfileReadHandler -> KeyfileReadHandler_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_KeyfileReadHandler

Arguments

:: (HasCallStack, MonadIO m, IsConnection a)

=> FunPtr C_KeyfileReadHandler

-> KeyFile

keyfile: the KeyFile that is currently read

-> a

connection: the Connection that is being constructed.

-> KeyfileHandlerType

handlerType: the NMKeyfileHandlerType that indicates which type the request is.

-> KeyfileHandlerData

handlerData: the KeyfileHandlerData. What you can do with it depends on the handlerType.

-> Ptr ()

userData: the user-data argument to keyfileRead.

-> m Bool

Returns: the callee should return TRUE, if the event was handled and/or recognized. Otherwise, a default action will be performed that depends on the type. For KeyfileHandlerTypeWarn type, the default action is doing nothing.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_KeyfileReadHandler :: MonadIO m => KeyfileReadHandler -> m (GClosure C_KeyfileReadHandler)

Wrap the callback into a GClosure.

mk_KeyfileReadHandler :: C_KeyfileReadHandler -> IO (FunPtr C_KeyfileReadHandler)

Generate a function pointer callable from C code, from a C_KeyfileReadHandler.

noKeyfileReadHandler :: Maybe KeyfileReadHandler

A convenience synonym for Nothing :: Maybe KeyfileReadHandler.

noKeyfileReadHandler_WithClosures :: Maybe KeyfileReadHandler_WithClosures

A convenience synonym for Nothing :: Maybe KeyfileReadHandler_WithClosures.

wrap_KeyfileReadHandler :: Maybe (Ptr (FunPtr C_KeyfileReadHandler)) -> KeyfileReadHandler_WithClosures -> C_KeyfileReadHandler

Wrap a KeyfileReadHandler into a C_KeyfileReadHandler.

KeyfileWriteHandler

type C_KeyfileWriteHandler = Ptr Connection -> Ptr KeyFile -> CUInt -> Ptr KeyfileHandlerData -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type KeyfileWriteHandler

Arguments

 = Connection

connection: the Connection that is currently written.

-> KeyFile

keyfile: the KeyFile that is currently constructed.

-> KeyfileHandlerType

handlerType: the NMKeyfileHandlerType that indicates which type the request is.

-> KeyfileHandlerData

handlerData: the KeyfileHandlerData. What you can do with it depends on the handlerType.

-> IO Bool

Returns: the callee should return True if the event was handled. If the event was unhandled, a default action will be performed that depends on the handlerType.

This is a hook to tweak the serialization.

Handler for certain properties or events that are not entirely contained within the keyfile or that might be serialized differently. The type and handlerData arguments tell which kind of argument we have at hand.

Currently only the type KeyfileHandlerTypeWriteCert is supported.

The callee may call keyfileHandlerDataFailWithError to abort the writing with error.

Since: 1.30

type KeyfileWriteHandler_WithClosures

Arguments

 = Connection

connection: the Connection that is currently written.

-> KeyFile

keyfile: the KeyFile that is currently constructed.

-> KeyfileHandlerType

handlerType: the NMKeyfileHandlerType that indicates which type the request is.

-> KeyfileHandlerData

handlerData: the KeyfileHandlerData. What you can do with it depends on the handlerType.

-> Ptr ()

userData: the user-data argument to keyfileRead.

-> IO Bool

Returns: the callee should return True if the event was handled. If the event was unhandled, a default action will be performed that depends on the handlerType.

This is a hook to tweak the serialization.

Handler for certain properties or events that are not entirely contained within the keyfile or that might be serialized differently. The type and handlerData arguments tell which kind of argument we have at hand.

Currently only the type KeyfileHandlerTypeWriteCert is supported.

The callee may call keyfileHandlerDataFailWithError to abort the writing with error.

Since: 1.30

drop_closures_KeyfileWriteHandler :: KeyfileWriteHandler -> KeyfileWriteHandler_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_KeyfileWriteHandler

Arguments

:: (HasCallStack, MonadIO m, IsConnection a)

=> FunPtr C_KeyfileWriteHandler

-> a

connection: the Connection that is currently written.

-> KeyFile

keyfile: the KeyFile that is currently constructed.

-> KeyfileHandlerType

handlerType: the NMKeyfileHandlerType that indicates which type the request is.

-> KeyfileHandlerData

handlerData: the KeyfileHandlerData. What you can do with it depends on the handlerType.

-> Ptr ()

userData: the user-data argument to keyfileRead.

-> m Bool

Returns: the callee should return True if the event was handled. If the event was unhandled, a default action will be performed that depends on the handlerType.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_KeyfileWriteHandler :: MonadIO m => KeyfileWriteHandler -> m (GClosure C_KeyfileWriteHandler)

Wrap the callback into a GClosure.

mk_KeyfileWriteHandler :: C_KeyfileWriteHandler -> IO (FunPtr C_KeyfileWriteHandler)

Generate a function pointer callable from C code, from a C_KeyfileWriteHandler.

noKeyfileWriteHandler :: Maybe KeyfileWriteHandler

A convenience synonym for Nothing :: Maybe KeyfileWriteHandler.

noKeyfileWriteHandler_WithClosures :: Maybe KeyfileWriteHandler_WithClosures

A convenience synonym for Nothing :: Maybe KeyfileWriteHandler_WithClosures.

wrap_KeyfileWriteHandler :: Maybe (Ptr (FunPtr C_KeyfileWriteHandler)) -> KeyfileWriteHandler_WithClosures -> C_KeyfileWriteHandler

Wrap a KeyfileWriteHandler into a C_KeyfileWriteHandler.

SecretAgentOldDeleteSecretsFunc

type C_SecretAgentOldDeleteSecretsFunc = Ptr SecretAgentOld -> Ptr Connection -> Ptr GError -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type SecretAgentOldDeleteSecretsFunc

Arguments

 = SecretAgentOld

agent: the secret agent object

-> Connection

connection: the connection for which secrets were to be deleted, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GError

error: if the deleting secrets failed, give a descriptive error here

-> IO ()

Called as a result of a request by NM to delete secrets. When the SecretAgentOld subclass has finished deleting the secrets, this function should be called.

type SecretAgentOldDeleteSecretsFunc_WithClosures

Arguments

 = SecretAgentOld

agent: the secret agent object

-> Connection

connection: the connection for which secrets were to be deleted, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GError

error: if the deleting secrets failed, give a descriptive error here

-> Ptr ()

userData: caller-specific data to be passed to the function

-> IO ()

Called as a result of a request by NM to delete secrets. When the SecretAgentOld subclass has finished deleting the secrets, this function should be called.

drop_closures_SecretAgentOldDeleteSecretsFunc :: SecretAgentOldDeleteSecretsFunc -> SecretAgentOldDeleteSecretsFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SecretAgentOldDeleteSecretsFunc

Arguments

:: (HasCallStack, MonadIO m, IsSecretAgentOld a, IsConnection b)

=> FunPtr C_SecretAgentOldDeleteSecretsFunc

-> a

agent: the secret agent object

-> b

connection: the connection for which secrets were to be deleted, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GError

error: if the deleting secrets failed, give a descriptive error here

-> Ptr ()

userData: caller-specific data to be passed to the function

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SecretAgentOldDeleteSecretsFunc :: MonadIO m => SecretAgentOldDeleteSecretsFunc -> m (GClosure C_SecretAgentOldDeleteSecretsFunc)

Wrap the callback into a GClosure.

mk_SecretAgentOldDeleteSecretsFunc :: C_SecretAgentOldDeleteSecretsFunc -> IO (FunPtr C_SecretAgentOldDeleteSecretsFunc)

Generate a function pointer callable from C code, from a C_SecretAgentOldDeleteSecretsFunc.

noSecretAgentOldDeleteSecretsFunc :: Maybe SecretAgentOldDeleteSecretsFunc

A convenience synonym for Nothing :: Maybe SecretAgentOldDeleteSecretsFunc.

noSecretAgentOldDeleteSecretsFunc_WithClosures :: Maybe SecretAgentOldDeleteSecretsFunc_WithClosures

A convenience synonym for Nothing :: Maybe SecretAgentOldDeleteSecretsFunc_WithClosures.

wrap_SecretAgentOldDeleteSecretsFunc :: Maybe (Ptr (FunPtr C_SecretAgentOldDeleteSecretsFunc)) -> SecretAgentOldDeleteSecretsFunc_WithClosures -> C_SecretAgentOldDeleteSecretsFunc

Wrap a SecretAgentOldDeleteSecretsFunc into a C_SecretAgentOldDeleteSecretsFunc.

SecretAgentOldGetSecretsFunc

type C_SecretAgentOldGetSecretsFunc = Ptr SecretAgentOld -> Ptr Connection -> Ptr GVariant -> Ptr GError -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type SecretAgentOldGetSecretsFunc

Arguments

 = SecretAgentOld

agent: the secret agent object

-> Connection

connection: the connection for which secrets were requested, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GVariant

secrets: the GVariant of type NM_VARIANT_TYPE_CONNECTION containing the requested secrets (as created by connectionToDbus for example). Each key in secrets should be the name of a Setting object (like "802-11-wireless-security") and each value should be an NM_VARIANT_TYPE_SETTING variant. The sub-dicts map string:value, where the string is the setting property name (like "psk") and the value is the secret

-> GError

error: if the secrets request failed, give a descriptive error here

-> IO ()

Called as a result of a request by NM to retrieve secrets. When the SecretAgentOld subclass has finished retrieving secrets and is ready to return them, or to return an error, this function should be called with those secrets or the error.

To easily create the dictionary to return the Wi-Fi PSK, you could do something like this: <example> <title>Creating a secrets dictionary</title> <programlisting> NMConnection *secrets; NMSettingWirelessSecurity *s_wsec; GVariant *secrets_dict;

secrets = nm_simple_connection_new (); s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new (); g_object_set (G_OBJECT (s_wsec), NM_SETTING_WIRELESS_SECURITY_PSK, "my really cool PSK", NULL); nm_connection_add_setting (secrets, NM_SETTING (s_wsec)); secrets_dict = nm_connection_to_dbus (secrets, NM_CONNECTION_SERIALIZE_ALL);

(call the NMSecretAgentOldGetSecretsFunc with secrets_dict)

g_object_unref (secrets); g_variant_unref (secrets_dict); </programlisting> </example>

type SecretAgentOldGetSecretsFunc_WithClosures

Arguments

 = SecretAgentOld

agent: the secret agent object

-> Connection

connection: the connection for which secrets were requested, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GVariant

secrets: the GVariant of type NM_VARIANT_TYPE_CONNECTION containing the requested secrets (as created by connectionToDbus for example). Each key in secrets should be the name of a Setting object (like "802-11-wireless-security") and each value should be an NM_VARIANT_TYPE_SETTING variant. The sub-dicts map string:value, where the string is the setting property name (like "psk") and the value is the secret

-> GError

error: if the secrets request failed, give a descriptive error here

-> Ptr ()

userData: caller-specific data to be passed to the function

-> IO ()

Called as a result of a request by NM to retrieve secrets. When the SecretAgentOld subclass has finished retrieving secrets and is ready to return them, or to return an error, this function should be called with those secrets or the error.

To easily create the dictionary to return the Wi-Fi PSK, you could do something like this: <example> <title>Creating a secrets dictionary</title> <programlisting> NMConnection *secrets; NMSettingWirelessSecurity *s_wsec; GVariant *secrets_dict;

secrets = nm_simple_connection_new (); s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new (); g_object_set (G_OBJECT (s_wsec), NM_SETTING_WIRELESS_SECURITY_PSK, "my really cool PSK", NULL); nm_connection_add_setting (secrets, NM_SETTING (s_wsec)); secrets_dict = nm_connection_to_dbus (secrets, NM_CONNECTION_SERIALIZE_ALL);

(call the NMSecretAgentOldGetSecretsFunc with secrets_dict)

g_object_unref (secrets); g_variant_unref (secrets_dict); </programlisting> </example>

drop_closures_SecretAgentOldGetSecretsFunc :: SecretAgentOldGetSecretsFunc -> SecretAgentOldGetSecretsFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SecretAgentOldGetSecretsFunc

Arguments

:: (HasCallStack, MonadIO m, IsSecretAgentOld a, IsConnection b)

=> FunPtr C_SecretAgentOldGetSecretsFunc

-> a

agent: the secret agent object

-> b

connection: the connection for which secrets were requested, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GVariant

secrets: the GVariant of type NM_VARIANT_TYPE_CONNECTION containing the requested secrets (as created by connectionToDbus for example). Each key in secrets should be the name of a Setting object (like "802-11-wireless-security") and each value should be an NM_VARIANT_TYPE_SETTING variant. The sub-dicts map string:value, where the string is the setting property name (like "psk") and the value is the secret

-> GError

error: if the secrets request failed, give a descriptive error here

-> Ptr ()

userData: caller-specific data to be passed to the function

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SecretAgentOldGetSecretsFunc :: MonadIO m => SecretAgentOldGetSecretsFunc -> m (GClosure C_SecretAgentOldGetSecretsFunc)

Wrap the callback into a GClosure.

mk_SecretAgentOldGetSecretsFunc :: C_SecretAgentOldGetSecretsFunc -> IO (FunPtr C_SecretAgentOldGetSecretsFunc)

Generate a function pointer callable from C code, from a C_SecretAgentOldGetSecretsFunc.

noSecretAgentOldGetSecretsFunc :: Maybe SecretAgentOldGetSecretsFunc

A convenience synonym for Nothing :: Maybe SecretAgentOldGetSecretsFunc.

noSecretAgentOldGetSecretsFunc_WithClosures :: Maybe SecretAgentOldGetSecretsFunc_WithClosures

A convenience synonym for Nothing :: Maybe SecretAgentOldGetSecretsFunc_WithClosures.

wrap_SecretAgentOldGetSecretsFunc :: Maybe (Ptr (FunPtr C_SecretAgentOldGetSecretsFunc)) -> SecretAgentOldGetSecretsFunc_WithClosures -> C_SecretAgentOldGetSecretsFunc

Wrap a SecretAgentOldGetSecretsFunc into a C_SecretAgentOldGetSecretsFunc.

SecretAgentOldSaveSecretsFunc

type C_SecretAgentOldSaveSecretsFunc = Ptr SecretAgentOld -> Ptr Connection -> Ptr GError -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type SecretAgentOldSaveSecretsFunc

Arguments

 = SecretAgentOld

agent: the secret agent object

-> Connection

connection: the connection for which secrets were to be saved, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GError

error: if the saving secrets failed, give a descriptive error here

-> IO ()

Called as a result of a request by NM to save secrets. When the SecretAgentOld subclass has finished saving the secrets, this function should be called.

type SecretAgentOldSaveSecretsFunc_WithClosures

Arguments

 = SecretAgentOld

agent: the secret agent object

-> Connection

connection: the connection for which secrets were to be saved, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GError

error: if the saving secrets failed, give a descriptive error here

-> Ptr ()

userData: caller-specific data to be passed to the function

-> IO ()

Called as a result of a request by NM to save secrets. When the SecretAgentOld subclass has finished saving the secrets, this function should be called.

drop_closures_SecretAgentOldSaveSecretsFunc :: SecretAgentOldSaveSecretsFunc -> SecretAgentOldSaveSecretsFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SecretAgentOldSaveSecretsFunc

Arguments

:: (HasCallStack, MonadIO m, IsSecretAgentOld a, IsConnection b)

=> FunPtr C_SecretAgentOldSaveSecretsFunc

-> a

agent: the secret agent object

-> b

connection: the connection for which secrets were to be saved, note that this object will be unrefed after the callback has returned, use objectRef/objectUnref if you want to use this object after the callback has returned

-> GError

error: if the saving secrets failed, give a descriptive error here

-> Ptr ()

userData: caller-specific data to be passed to the function

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SecretAgentOldSaveSecretsFunc :: MonadIO m => SecretAgentOldSaveSecretsFunc -> m (GClosure C_SecretAgentOldSaveSecretsFunc)

Wrap the callback into a GClosure.

mk_SecretAgentOldSaveSecretsFunc :: C_SecretAgentOldSaveSecretsFunc -> IO (FunPtr C_SecretAgentOldSaveSecretsFunc)

Generate a function pointer callable from C code, from a C_SecretAgentOldSaveSecretsFunc.

noSecretAgentOldSaveSecretsFunc :: Maybe SecretAgentOldSaveSecretsFunc

A convenience synonym for Nothing :: Maybe SecretAgentOldSaveSecretsFunc.

noSecretAgentOldSaveSecretsFunc_WithClosures :: Maybe SecretAgentOldSaveSecretsFunc_WithClosures

A convenience synonym for Nothing :: Maybe SecretAgentOldSaveSecretsFunc_WithClosures.

wrap_SecretAgentOldSaveSecretsFunc :: Maybe (Ptr (FunPtr C_SecretAgentOldSaveSecretsFunc)) -> SecretAgentOldSaveSecretsFunc_WithClosures -> C_SecretAgentOldSaveSecretsFunc

Wrap a SecretAgentOldSaveSecretsFunc into a C_SecretAgentOldSaveSecretsFunc.

SettingClearSecretsWithFlagsFn

type C_SettingClearSecretsWithFlagsFn = Ptr Setting -> CString -> CUInt -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type SettingClearSecretsWithFlagsFn

Arguments

 = Setting

setting: The setting for which secrets are being iterated

-> Text

secret: The secret's name

-> [SettingSecretFlags]

flags: The secret's flags, eg SettingSecretFlagsAgentOwned

-> IO Bool

Returns: True to clear the secret, False to not clear the secret

No description available in the introspection data.

type SettingClearSecretsWithFlagsFn_WithClosures

Arguments

 = Setting

setting: The setting for which secrets are being iterated

-> Text

secret: The secret's name

-> [SettingSecretFlags]

flags: The secret's flags, eg SettingSecretFlagsAgentOwned

-> Ptr ()

userData: User data passed to connectionClearSecretsWithFlags

-> IO Bool

Returns: True to clear the secret, False to not clear the secret

No description available in the introspection data.

drop_closures_SettingClearSecretsWithFlagsFn :: SettingClearSecretsWithFlagsFn -> SettingClearSecretsWithFlagsFn_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SettingClearSecretsWithFlagsFn

Arguments

:: (HasCallStack, MonadIO m, IsSetting a)

=> FunPtr C_SettingClearSecretsWithFlagsFn

-> a

setting: The setting for which secrets are being iterated

-> Text

secret: The secret's name

-> [SettingSecretFlags]

flags: The secret's flags, eg SettingSecretFlagsAgentOwned

-> Ptr ()

userData: User data passed to connectionClearSecretsWithFlags

-> m Bool

Returns: True to clear the secret, False to not clear the secret

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SettingClearSecretsWithFlagsFn :: MonadIO m => SettingClearSecretsWithFlagsFn -> m (GClosure C_SettingClearSecretsWithFlagsFn)

Wrap the callback into a GClosure.

mk_SettingClearSecretsWithFlagsFn :: C_SettingClearSecretsWithFlagsFn -> IO (FunPtr C_SettingClearSecretsWithFlagsFn)

Generate a function pointer callable from C code, from a C_SettingClearSecretsWithFlagsFn.

noSettingClearSecretsWithFlagsFn :: Maybe SettingClearSecretsWithFlagsFn

A convenience synonym for Nothing :: Maybe SettingClearSecretsWithFlagsFn.

noSettingClearSecretsWithFlagsFn_WithClosures :: Maybe SettingClearSecretsWithFlagsFn_WithClosures

A convenience synonym for Nothing :: Maybe SettingClearSecretsWithFlagsFn_WithClosures.

wrap_SettingClearSecretsWithFlagsFn :: Maybe (Ptr (FunPtr C_SettingClearSecretsWithFlagsFn)) -> SettingClearSecretsWithFlagsFn_WithClosures -> C_SettingClearSecretsWithFlagsFn

Wrap a SettingClearSecretsWithFlagsFn into a C_SettingClearSecretsWithFlagsFn.

SettingValueIterFn

type C_SettingValueIterFn = Ptr Setting -> CString -> Ptr GValue -> CUInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type SettingValueIterFn

Arguments

 = Setting

setting: The setting for which properties are being iterated, given to settingEnumerateValues

-> Text

key: The value/property name

-> GValue

value: The property's value

-> [ParamFlags]

flags: The property's flags, like SETTING_PARAM_SECRET

-> IO ()

No description available in the introspection data.

type SettingValueIterFn_WithClosures

Arguments

 = Setting

setting: The setting for which properties are being iterated, given to settingEnumerateValues

-> Text

key: The value/property name

-> GValue

value: The property's value

-> [ParamFlags]

flags: The property's flags, like SETTING_PARAM_SECRET

-> Ptr ()

userData: User data passed to settingEnumerateValues

-> IO ()

No description available in the introspection data.

drop_closures_SettingValueIterFn :: SettingValueIterFn -> SettingValueIterFn_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SettingValueIterFn

Arguments

:: (HasCallStack, MonadIO m, IsSetting a)

=> FunPtr C_SettingValueIterFn

-> a

setting: The setting for which properties are being iterated, given to settingEnumerateValues

-> Text

key: The value/property name

-> GValue

value: The property's value

-> [ParamFlags]

flags: The property's flags, like SETTING_PARAM_SECRET

-> Ptr ()

userData: User data passed to settingEnumerateValues

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SettingValueIterFn :: MonadIO m => SettingValueIterFn -> m (GClosure C_SettingValueIterFn)

Wrap the callback into a GClosure.

mk_SettingValueIterFn :: C_SettingValueIterFn -> IO (FunPtr C_SettingValueIterFn)

Generate a function pointer callable from C code, from a C_SettingValueIterFn.

noSettingValueIterFn :: Maybe SettingValueIterFn

A convenience synonym for Nothing :: Maybe SettingValueIterFn.

noSettingValueIterFn_WithClosures :: Maybe SettingValueIterFn_WithClosures

A convenience synonym for Nothing :: Maybe SettingValueIterFn_WithClosures.

wrap_SettingValueIterFn :: Maybe (Ptr (FunPtr C_SettingValueIterFn)) -> SettingValueIterFn_WithClosures -> C_SettingValueIterFn

Wrap a SettingValueIterFn into a C_SettingValueIterFn.

UtilsCheckFilePredicate

type C_UtilsCheckFilePredicate = CString -> Ptr () -> Ptr () -> Ptr (Ptr GError) -> IO CInt

Type for the callback on the (unwrapped) C side.

type UtilsCheckFilePredicate

Arguments

 = Text

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

type UtilsCheckFilePredicate_WithClosures

Arguments

 = Text

-> Ptr ()

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

drop_closures_UtilsCheckFilePredicate :: UtilsCheckFilePredicate -> UtilsCheckFilePredicate_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_UtilsCheckFilePredicate

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_UtilsCheckFilePredicate

-> Text

-> Ptr ()

-> Ptr ()

-> m ()

(Can throw GError)

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

mk_UtilsCheckFilePredicate :: C_UtilsCheckFilePredicate -> IO (FunPtr C_UtilsCheckFilePredicate)

Generate a function pointer callable from C code, from a C_UtilsCheckFilePredicate.

noUtilsCheckFilePredicate :: Maybe UtilsCheckFilePredicate

A convenience synonym for Nothing :: Maybe UtilsCheckFilePredicate.

noUtilsCheckFilePredicate_WithClosures :: Maybe UtilsCheckFilePredicate_WithClosures

A convenience synonym for Nothing :: Maybe UtilsCheckFilePredicate_WithClosures.

UtilsFileSearchInPathsPredicate

type C_UtilsFileSearchInPathsPredicate = CString -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type UtilsFileSearchInPathsPredicate = Text -> IO Bool

No description available in the introspection data.

type UtilsFileSearchInPathsPredicate_WithClosures = Text -> Ptr () -> IO Bool

No description available in the introspection data.

drop_closures_UtilsFileSearchInPathsPredicate :: UtilsFileSearchInPathsPredicate -> UtilsFileSearchInPathsPredicate_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_UtilsFileSearchInPathsPredicate :: (HasCallStack, MonadIO m) => FunPtr C_UtilsFileSearchInPathsPredicate -> Text -> Ptr () -> m Bool

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_UtilsFileSearchInPathsPredicate :: MonadIO m => UtilsFileSearchInPathsPredicate -> m (GClosure C_UtilsFileSearchInPathsPredicate)

Wrap the callback into a GClosure.

mk_UtilsFileSearchInPathsPredicate :: C_UtilsFileSearchInPathsPredicate -> IO (FunPtr C_UtilsFileSearchInPathsPredicate)

Generate a function pointer callable from C code, from a C_UtilsFileSearchInPathsPredicate.

noUtilsFileSearchInPathsPredicate :: Maybe UtilsFileSearchInPathsPredicate

A convenience synonym for Nothing :: Maybe UtilsFileSearchInPathsPredicate.

noUtilsFileSearchInPathsPredicate_WithClosures :: Maybe UtilsFileSearchInPathsPredicate_WithClosures

A convenience synonym for Nothing :: Maybe UtilsFileSearchInPathsPredicate_WithClosures.

wrap_UtilsFileSearchInPathsPredicate :: Maybe (Ptr (FunPtr C_UtilsFileSearchInPathsPredicate)) -> UtilsFileSearchInPathsPredicate_WithClosures -> C_UtilsFileSearchInPathsPredicate

Wrap a UtilsFileSearchInPathsPredicate into a C_UtilsFileSearchInPathsPredicate.

UtilsPredicateStr

type C_UtilsPredicateStr = CString -> IO CInt

Type for the callback on the (unwrapped) C side.

type UtilsPredicateStr

Arguments

 = Text

str: the name to check.

-> IO Bool

Returns: True if the predicate function matches.

This function takes a string argument and returns either True or False. It is a general purpose predicate, for example used by settingOptionClearByName.

Since: 1.26

dynamic_UtilsPredicateStr

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_UtilsPredicateStr

-> Text

str: the name to check.

-> m Bool

Returns: True if the predicate function matches.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_UtilsPredicateStr :: MonadIO m => UtilsPredicateStr -> m (GClosure C_UtilsPredicateStr)

Wrap the callback into a GClosure.

mk_UtilsPredicateStr :: C_UtilsPredicateStr -> IO (FunPtr C_UtilsPredicateStr)

Generate a function pointer callable from C code, from a C_UtilsPredicateStr.

noUtilsPredicateStr :: Maybe UtilsPredicateStr

A convenience synonym for Nothing :: Maybe UtilsPredicateStr.

wrap_UtilsPredicateStr :: Maybe (Ptr (FunPtr C_UtilsPredicateStr)) -> UtilsPredicateStr -> C_UtilsPredicateStr

Wrap a UtilsPredicateStr into a C_UtilsPredicateStr.

VpnIterFunc

type C_VpnIterFunc = CString -> CString -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type VpnIterFunc

Arguments

 = Text

key: the name of the data or secret item

-> Text

value: the value of the data or secret item

-> IO ()

No description available in the introspection data.

type VpnIterFunc_WithClosures

Arguments

 = Text

key: the name of the data or secret item

-> Text

value: the value of the data or secret item

-> Ptr ()

userData: User data passed to settingVpnForeachDataItem or settingVpnForeachSecret

-> IO ()

No description available in the introspection data.

drop_closures_VpnIterFunc :: VpnIterFunc -> VpnIterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_VpnIterFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_VpnIterFunc

-> Text

key: the name of the data or secret item

-> Text

value: the value of the data or secret item

-> Ptr ()

userData: User data passed to settingVpnForeachDataItem or settingVpnForeachSecret

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_VpnIterFunc :: MonadIO m => VpnIterFunc -> m (GClosure C_VpnIterFunc)

Wrap the callback into a GClosure.

mk_VpnIterFunc :: C_VpnIterFunc -> IO (FunPtr C_VpnIterFunc)

Generate a function pointer callable from C code, from a C_VpnIterFunc.

noVpnIterFunc :: Maybe VpnIterFunc

A convenience synonym for Nothing :: Maybe VpnIterFunc.

noVpnIterFunc_WithClosures :: Maybe VpnIterFunc_WithClosures

A convenience synonym for Nothing :: Maybe VpnIterFunc_WithClosures.

wrap_VpnIterFunc :: Maybe (Ptr (FunPtr C_VpnIterFunc)) -> VpnIterFunc_WithClosures -> C_VpnIterFunc

Wrap a VpnIterFunc into a C_VpnIterFunc.