GI.JavaScriptCore.Callbacks

Signals

ClassDeletePropertyFunction

type C_ClassDeletePropertyFunction = Ptr Class -> Ptr Context -> Ptr () -> CString -> IO CInt

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

type ClassDeletePropertyFunction

Arguments

 = Class

jscClass: a Class

-> Context

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> IO Bool

Returns: True if handled or False to to forward the request to the parent class or prototype chain.

The type of delete_property in ClassVTable. This is only required when you need to handle external properties not added to the prototype.

dynamic_ClassDeletePropertyFunction

Arguments

:: (HasCallStack, MonadIO m, IsClass a, IsContext b)

=> FunPtr C_ClassDeletePropertyFunction

-> a

jscClass: a Class

-> b

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> m Bool

Returns: True if handled or False to to forward the request to the parent class or prototype chain.

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

genClosure_ClassDeletePropertyFunction :: MonadIO m => ClassDeletePropertyFunction -> m (GClosure C_ClassDeletePropertyFunction)

Wrap the callback into a GClosure.

mk_ClassDeletePropertyFunction :: C_ClassDeletePropertyFunction -> IO (FunPtr C_ClassDeletePropertyFunction)

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

noClassDeletePropertyFunction :: Maybe ClassDeletePropertyFunction

A convenience synonym for Nothing :: Maybe ClassDeletePropertyFunction.

wrap_ClassDeletePropertyFunction :: Maybe (Ptr (FunPtr C_ClassDeletePropertyFunction)) -> ClassDeletePropertyFunction -> C_ClassDeletePropertyFunction

Wrap a ClassDeletePropertyFunction into a C_ClassDeletePropertyFunction.

ClassEnumeratePropertiesFunction

type C_ClassEnumeratePropertiesFunction = Ptr Class -> Ptr Context -> Ptr () -> IO (Ptr CString)

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

type ClassEnumeratePropertiesFunction

Arguments

 = Class

jscClass: a Class

-> Context

context: a Context

-> Ptr ()

instance: the jscClass instance

-> IO (Maybe [Text])

Returns: a Nothing-terminated array of strings containing the property names, or Nothing if instance doesn't have enumerable properties.

The type of enumerate_properties in ClassVTable. This is only required when you need to handle external properties not added to the prototype.

dynamic_ClassEnumeratePropertiesFunction

Arguments

:: (HasCallStack, MonadIO m, IsClass a, IsContext b)

=> FunPtr C_ClassEnumeratePropertiesFunction

-> a

jscClass: a Class

-> b

context: a Context

-> Ptr ()

instance: the jscClass instance

-> m (Maybe [Text])

Returns: a Nothing-terminated array of strings containing the property names, or Nothing if instance doesn't have enumerable properties.

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

genClosure_ClassEnumeratePropertiesFunction :: MonadIO m => ClassEnumeratePropertiesFunction -> m (GClosure C_ClassEnumeratePropertiesFunction)

Wrap the callback into a GClosure.

mk_ClassEnumeratePropertiesFunction :: C_ClassEnumeratePropertiesFunction -> IO (FunPtr C_ClassEnumeratePropertiesFunction)

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

noClassEnumeratePropertiesFunction :: Maybe ClassEnumeratePropertiesFunction

A convenience synonym for Nothing :: Maybe ClassEnumeratePropertiesFunction.

wrap_ClassEnumeratePropertiesFunction :: Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction)) -> ClassEnumeratePropertiesFunction -> C_ClassEnumeratePropertiesFunction

Wrap a ClassEnumeratePropertiesFunction into a C_ClassEnumeratePropertiesFunction.

ClassGetPropertyFunction

type C_ClassGetPropertyFunction = Ptr Class -> Ptr Context -> Ptr () -> CString -> IO (Ptr Value)

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

type ClassGetPropertyFunction

Arguments

 = Class

jscClass: a Class

-> Context

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> IO (Maybe Value)

Returns: a Value or Nothing to forward the request to the parent class or prototype chain

The type of get_property in ClassVTable. This is only required when you need to handle external properties not added to the prototype.

dynamic_ClassGetPropertyFunction

Arguments

:: (HasCallStack, MonadIO m, IsClass a, IsContext b)

=> FunPtr C_ClassGetPropertyFunction

-> a

jscClass: a Class

-> b

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> m (Maybe Value)

Returns: a Value or Nothing to forward the request to the parent class or prototype chain

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

genClosure_ClassGetPropertyFunction :: MonadIO m => ClassGetPropertyFunction -> m (GClosure C_ClassGetPropertyFunction)

Wrap the callback into a GClosure.

mk_ClassGetPropertyFunction :: C_ClassGetPropertyFunction -> IO (FunPtr C_ClassGetPropertyFunction)

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

noClassGetPropertyFunction :: Maybe ClassGetPropertyFunction

A convenience synonym for Nothing :: Maybe ClassGetPropertyFunction.

wrap_ClassGetPropertyFunction :: Maybe (Ptr (FunPtr C_ClassGetPropertyFunction)) -> ClassGetPropertyFunction -> C_ClassGetPropertyFunction

Wrap a ClassGetPropertyFunction into a C_ClassGetPropertyFunction.

ClassHasPropertyFunction

type C_ClassHasPropertyFunction = Ptr Class -> Ptr Context -> Ptr () -> CString -> IO CInt

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

type ClassHasPropertyFunction

Arguments

 = Class

jscClass: a Class

-> Context

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> IO Bool

Returns: True if instance has a property with name or False to forward the request to the parent class or prototype chain.

The type of has_property in ClassVTable. This is only required when you need to handle external properties not added to the prototype.

dynamic_ClassHasPropertyFunction

Arguments

:: (HasCallStack, MonadIO m, IsClass a, IsContext b)

=> FunPtr C_ClassHasPropertyFunction

-> a

jscClass: a Class

-> b

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> m Bool

Returns: True if instance has a property with name or False to forward the request to the parent class or prototype chain.

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

genClosure_ClassHasPropertyFunction :: MonadIO m => ClassHasPropertyFunction -> m (GClosure C_ClassHasPropertyFunction)

Wrap the callback into a GClosure.

mk_ClassHasPropertyFunction :: C_ClassHasPropertyFunction -> IO (FunPtr C_ClassHasPropertyFunction)

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

noClassHasPropertyFunction :: Maybe ClassHasPropertyFunction

A convenience synonym for Nothing :: Maybe ClassHasPropertyFunction.

wrap_ClassHasPropertyFunction :: Maybe (Ptr (FunPtr C_ClassHasPropertyFunction)) -> ClassHasPropertyFunction -> C_ClassHasPropertyFunction

Wrap a ClassHasPropertyFunction into a C_ClassHasPropertyFunction.

ClassSetPropertyFunction

type C_ClassSetPropertyFunction = Ptr Class -> Ptr Context -> Ptr () -> CString -> Ptr Value -> IO CInt

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

type ClassSetPropertyFunction

Arguments

 = Class

jscClass: a Class

-> Context

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> Value

value: the Value to set

-> IO Bool

Returns: True if handled or False to forward the request to the parent class or prototype chain.

The type of set_property in ClassVTable. This is only required when you need to handle external properties not added to the prototype.

dynamic_ClassSetPropertyFunction

Arguments

:: (HasCallStack, MonadIO m, IsClass a, IsContext b, IsValue c)

=> FunPtr C_ClassSetPropertyFunction

-> a

jscClass: a Class

-> b

context: a Context

-> Ptr ()

instance: the jscClass instance

-> Text

name: the property name

-> c

value: the Value to set

-> m Bool

Returns: True if handled or False to forward the request to the parent class or prototype chain.

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

genClosure_ClassSetPropertyFunction :: MonadIO m => ClassSetPropertyFunction -> m (GClosure C_ClassSetPropertyFunction)

Wrap the callback into a GClosure.

mk_ClassSetPropertyFunction :: C_ClassSetPropertyFunction -> IO (FunPtr C_ClassSetPropertyFunction)

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

noClassSetPropertyFunction :: Maybe ClassSetPropertyFunction

A convenience synonym for Nothing :: Maybe ClassSetPropertyFunction.

wrap_ClassSetPropertyFunction :: Maybe (Ptr (FunPtr C_ClassSetPropertyFunction)) -> ClassSetPropertyFunction -> C_ClassSetPropertyFunction

Wrap a ClassSetPropertyFunction into a C_ClassSetPropertyFunction.

ExceptionHandler

type C_ExceptionHandler = Ptr Context -> Ptr Exception -> Ptr () -> IO ()

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

type ExceptionHandler

Arguments

 = Context

context: a Context

-> Exception

exception: a Exception

-> IO ()

Function used to handle JavaScript exceptions in a Context.

type ExceptionHandler_WithClosures

Arguments

 = Context

context: a Context

-> Exception

exception: a Exception

-> Ptr ()

userData: user data

-> IO ()

Function used to handle JavaScript exceptions in a Context.

drop_closures_ExceptionHandler :: ExceptionHandler -> ExceptionHandler_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ExceptionHandler

Arguments

:: (HasCallStack, MonadIO m, IsContext a, IsException b)

=> FunPtr C_ExceptionHandler

-> a

context: a Context

-> b

exception: a Exception

-> Ptr ()

userData: user data

-> m ()

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

genClosure_ExceptionHandler :: MonadIO m => ExceptionHandler -> m (GClosure C_ExceptionHandler)

Wrap the callback into a GClosure.

mk_ExceptionHandler :: C_ExceptionHandler -> IO (FunPtr C_ExceptionHandler)

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

noExceptionHandler :: Maybe ExceptionHandler

A convenience synonym for Nothing :: Maybe ExceptionHandler.

noExceptionHandler_WithClosures :: Maybe ExceptionHandler_WithClosures

A convenience synonym for Nothing :: Maybe ExceptionHandler_WithClosures.

wrap_ExceptionHandler :: Maybe (Ptr (FunPtr C_ExceptionHandler)) -> ExceptionHandler_WithClosures -> C_ExceptionHandler

Wrap a ExceptionHandler into a C_ExceptionHandler.

OptionsFunc

type C_OptionsFunc = CString -> CUInt -> CString -> Ptr () -> IO CInt

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

type OptionsFunc

Arguments

 = Text

option: the option name

-> OptionType

type: the option OptionType

-> Maybe Text

description: the option description, or Nothing

-> IO Bool

Returns: True to stop the iteration, or False otherwise

Function used to iterate options.

Not that description string is not localized.

Since: 2.24

type OptionsFunc_WithClosures

Arguments

 = Text

option: the option name

-> OptionType

type: the option OptionType

-> Maybe Text

description: the option description, or Nothing

-> Ptr ()

userData: user data

-> IO Bool

Returns: True to stop the iteration, or False otherwise

Function used to iterate options.

Not that description string is not localized.

Since: 2.24

drop_closures_OptionsFunc :: OptionsFunc -> OptionsFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_OptionsFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_OptionsFunc

-> Text

option: the option name

-> OptionType

type: the option OptionType

-> Maybe Text

description: the option description, or Nothing

-> Ptr ()

userData: user data

-> m Bool

Returns: True to stop the iteration, or False otherwise

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

genClosure_OptionsFunc :: MonadIO m => OptionsFunc -> m (GClosure C_OptionsFunc)

Wrap the callback into a GClosure.

mk_OptionsFunc :: C_OptionsFunc -> IO (FunPtr C_OptionsFunc)

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

noOptionsFunc :: Maybe OptionsFunc

A convenience synonym for Nothing :: Maybe OptionsFunc.

noOptionsFunc_WithClosures :: Maybe OptionsFunc_WithClosures

A convenience synonym for Nothing :: Maybe OptionsFunc_WithClosures.

wrap_OptionsFunc :: Maybe (Ptr (FunPtr C_OptionsFunc)) -> OptionsFunc_WithClosures -> C_OptionsFunc

Wrap a OptionsFunc into a C_OptionsFunc.