GI.Gtk.Callbacks

Signals

AccelGroupActivate

type AccelGroupActivate = AccelGroup -> Object -> Word32 -> [ModifierType] -> IO Bool

No description available in the introspection data.

type C_AccelGroupActivate = Ptr AccelGroup -> Ptr Object -> Word32 -> CUInt -> IO CInt

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

dynamic_AccelGroupActivate :: (HasCallStack, MonadIO m, IsAccelGroup a, IsObject b) => FunPtr C_AccelGroupActivate -> a -> b -> Word32 -> [ModifierType] -> m Bool

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

genClosure_AccelGroupActivate :: MonadIO m => AccelGroupActivate -> m (GClosure C_AccelGroupActivate)

Wrap the callback into a GClosure.

mk_AccelGroupActivate :: C_AccelGroupActivate -> IO (FunPtr C_AccelGroupActivate)

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

noAccelGroupActivate :: Maybe AccelGroupActivate

A convenience synonym for Nothing :: Maybe AccelGroupActivate.

wrap_AccelGroupActivate :: Maybe (Ptr (FunPtr C_AccelGroupActivate)) -> AccelGroupActivate -> C_AccelGroupActivate

Wrap a AccelGroupActivate into a C_AccelGroupActivate.

AccelGroupFindFunc

type AccelGroupFindFunc = AccelKey -> GClosure () -> IO Bool

No description available in the introspection data.

Since: 2.2

type AccelGroupFindFunc_WithClosures = AccelKey -> GClosure () -> Ptr () -> IO Bool

No description available in the introspection data.

Since: 2.2

type C_AccelGroupFindFunc = Ptr AccelKey -> Ptr (GClosure ()) -> Ptr () -> IO CInt

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

drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_AccelGroupFindFunc :: (HasCallStack, MonadIO m) => FunPtr C_AccelGroupFindFunc -> AccelKey -> GClosure a -> Ptr () -> m Bool

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

genClosure_AccelGroupFindFunc :: MonadIO m => AccelGroupFindFunc -> m (GClosure C_AccelGroupFindFunc)

Wrap the callback into a GClosure.

mk_AccelGroupFindFunc :: C_AccelGroupFindFunc -> IO (FunPtr C_AccelGroupFindFunc)

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

noAccelGroupFindFunc :: Maybe AccelGroupFindFunc

A convenience synonym for Nothing :: Maybe AccelGroupFindFunc.

noAccelGroupFindFunc_WithClosures :: Maybe AccelGroupFindFunc_WithClosures

A convenience synonym for Nothing :: Maybe AccelGroupFindFunc_WithClosures.

wrap_AccelGroupFindFunc :: Maybe (Ptr (FunPtr C_AccelGroupFindFunc)) -> AccelGroupFindFunc_WithClosures -> C_AccelGroupFindFunc

Wrap a AccelGroupFindFunc into a C_AccelGroupFindFunc.

AccelMapForeach

type AccelMapForeach

Arguments

 = Ptr ()

data: User data passed to accelMapForeach or accelMapForeachUnfiltered

-> Text

accelPath: Accel path of the current accelerator

-> Word32

accelKey: Key of the current accelerator

-> [ModifierType]

accelMods: Modifiers of the current accelerator

-> Bool

changed: Changed flag of the accelerator (if True, accelerator has changed during runtime and would need to be saved during an accelerator dump)

-> IO ()

No description available in the introspection data.

type C_AccelMapForeach = Ptr () -> CString -> Word32 -> CUInt -> CInt -> IO ()

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

dynamic_AccelMapForeach

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_AccelMapForeach

-> Ptr ()

data: User data passed to accelMapForeach or accelMapForeachUnfiltered

-> Text

accelPath: Accel path of the current accelerator

-> Word32

accelKey: Key of the current accelerator

-> [ModifierType]

accelMods: Modifiers of the current accelerator

-> Bool

changed: Changed flag of the accelerator (if True, accelerator has changed during runtime and would need to be saved during an accelerator dump)

-> m ()

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

genClosure_AccelMapForeach :: MonadIO m => AccelMapForeach -> m (GClosure C_AccelMapForeach)

Wrap the callback into a GClosure.

mk_AccelMapForeach :: C_AccelMapForeach -> IO (FunPtr C_AccelMapForeach)

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

noAccelMapForeach :: Maybe AccelMapForeach

A convenience synonym for Nothing :: Maybe AccelMapForeach.

wrap_AccelMapForeach :: Maybe (Ptr (FunPtr C_AccelMapForeach)) -> AccelMapForeach -> C_AccelMapForeach

Wrap a AccelMapForeach into a C_AccelMapForeach.

AssistantPageFunc

type AssistantPageFunc

Arguments

 = Int32

currentPage: The page number used to calculate the next page.

-> IO Int32

Returns: The next page number.

A function used by assistantSetForwardPageFunc to know which is the next page given a current one. It’s called both for computing the next page when the user presses the “forward” button and for handling the behavior of the “last” button.

type AssistantPageFunc_WithClosures

Arguments

 = Int32

currentPage: The page number used to calculate the next page.

-> Ptr ()

data: user data.

-> IO Int32

Returns: The next page number.

A function used by assistantSetForwardPageFunc to know which is the next page given a current one. It’s called both for computing the next page when the user presses the “forward” button and for handling the behavior of the “last” button.

type C_AssistantPageFunc = Int32 -> Ptr () -> IO Int32

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

drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_AssistantPageFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_AssistantPageFunc

-> Int32

currentPage: The page number used to calculate the next page.

-> Ptr ()

data: user data.

-> m Int32

Returns: The next page number.

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

genClosure_AssistantPageFunc :: MonadIO m => AssistantPageFunc -> m (GClosure C_AssistantPageFunc)

Wrap the callback into a GClosure.

mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)

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

noAssistantPageFunc :: Maybe AssistantPageFunc

A convenience synonym for Nothing :: Maybe AssistantPageFunc.

noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures

A convenience synonym for Nothing :: Maybe AssistantPageFunc_WithClosures.

wrap_AssistantPageFunc :: Maybe (Ptr (FunPtr C_AssistantPageFunc)) -> AssistantPageFunc_WithClosures -> C_AssistantPageFunc

Wrap a AssistantPageFunc into a C_AssistantPageFunc.

BuilderConnectFunc

type BuilderConnectFunc

Arguments

 = Builder

builder: a Builder

-> Object

object: object to connect a signal to

-> Text

signalName: name of the signal

-> Text

handlerName: name of the handler

-> Maybe Object

connectObject: a Object, if non-Nothing, use g_signal_connect_object()

-> [ConnectFlags]

flags: ConnectFlags to use

-> IO ()

This is the signature of a function used to connect signals. It is used by the builderConnectSignals and builderConnectSignalsFull methods. It is mainly intended for interpreted language bindings, but could be useful where the programmer wants more control over the signal connection process. Note that this function can only be called once, subsequent calls will do nothing.

Since: 2.12

type BuilderConnectFunc_WithClosures

Arguments

 = Builder

builder: a Builder

-> Object

object: object to connect a signal to

-> Text

signalName: name of the signal

-> Text

handlerName: name of the handler

-> Maybe Object

connectObject: a Object, if non-Nothing, use g_signal_connect_object()

-> [ConnectFlags]

flags: ConnectFlags to use

-> Ptr ()

userData: user data

-> IO ()

This is the signature of a function used to connect signals. It is used by the builderConnectSignals and builderConnectSignalsFull methods. It is mainly intended for interpreted language bindings, but could be useful where the programmer wants more control over the signal connection process. Note that this function can only be called once, subsequent calls will do nothing.

Since: 2.12

type C_BuilderConnectFunc = Ptr Builder -> Ptr Object -> CString -> CString -> Ptr Object -> CUInt -> Ptr () -> IO ()

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

drop_closures_BuilderConnectFunc :: BuilderConnectFunc -> BuilderConnectFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BuilderConnectFunc

Arguments

:: (HasCallStack, MonadIO m, IsBuilder a, IsObject b, IsObject c)

=> FunPtr C_BuilderConnectFunc

-> a

builder: a Builder

-> b

object: object to connect a signal to

-> Text

signalName: name of the signal

-> Text

handlerName: name of the handler

-> Maybe c

connectObject: a Object, if non-Nothing, use g_signal_connect_object()

-> [ConnectFlags]

flags: ConnectFlags to use

-> Ptr ()

userData: user data

-> m ()

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

genClosure_BuilderConnectFunc :: MonadIO m => BuilderConnectFunc -> m (GClosure C_BuilderConnectFunc)

Wrap the callback into a GClosure.

mk_BuilderConnectFunc :: C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc)

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

noBuilderConnectFunc :: Maybe BuilderConnectFunc

A convenience synonym for Nothing :: Maybe BuilderConnectFunc.

noBuilderConnectFunc_WithClosures :: Maybe BuilderConnectFunc_WithClosures

A convenience synonym for Nothing :: Maybe BuilderConnectFunc_WithClosures.

wrap_BuilderConnectFunc :: Maybe (Ptr (FunPtr C_BuilderConnectFunc)) -> BuilderConnectFunc_WithClosures -> C_BuilderConnectFunc

Wrap a BuilderConnectFunc into a C_BuilderConnectFunc.

CalendarDetailFunc

type C_CalendarDetailFunc = Ptr Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO CString

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

type CalendarDetailFunc

Arguments

 = Calendar

calendar: a Calendar.

-> Word32

year: the year for which details are needed.

-> Word32

month: the month for which details are needed.

-> Word32

day: the day of month for which details are needed.

-> IO (Maybe Text)

Returns: Newly allocated string with Pango markup with details for the specified day or Nothing.

This kind of functions provide Pango markup with detail information for the specified day. Examples for such details are holidays or appointments. The function returns Nothing when no information is available.

Since: 2.14

type CalendarDetailFunc_WithClosures

Arguments

 = Calendar

calendar: a Calendar.

-> Word32

year: the year for which details are needed.

-> Word32

month: the month for which details are needed.

-> Word32

day: the day of month for which details are needed.

-> Ptr ()

userData: the data passed with calendarSetDetailFunc.

-> IO (Maybe Text)

Returns: Newly allocated string with Pango markup with details for the specified day or Nothing.

This kind of functions provide Pango markup with detail information for the specified day. Examples for such details are holidays or appointments. The function returns Nothing when no information is available.

Since: 2.14

drop_closures_CalendarDetailFunc :: CalendarDetailFunc -> CalendarDetailFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CalendarDetailFunc

Arguments

:: (HasCallStack, MonadIO m, IsCalendar a)

=> FunPtr C_CalendarDetailFunc

-> a

calendar: a Calendar.

-> Word32

year: the year for which details are needed.

-> Word32

month: the month for which details are needed.

-> Word32

day: the day of month for which details are needed.

-> Ptr ()

userData: the data passed with calendarSetDetailFunc.

-> m (Maybe Text)

Returns: Newly allocated string with Pango markup with details for the specified day or Nothing.

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

genClosure_CalendarDetailFunc :: MonadIO m => CalendarDetailFunc -> m (GClosure C_CalendarDetailFunc)

Wrap the callback into a GClosure.

mk_CalendarDetailFunc :: C_CalendarDetailFunc -> IO (FunPtr C_CalendarDetailFunc)

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

noCalendarDetailFunc :: Maybe CalendarDetailFunc

A convenience synonym for Nothing :: Maybe CalendarDetailFunc.

noCalendarDetailFunc_WithClosures :: Maybe CalendarDetailFunc_WithClosures

A convenience synonym for Nothing :: Maybe CalendarDetailFunc_WithClosures.

wrap_CalendarDetailFunc :: Maybe (Ptr (FunPtr C_CalendarDetailFunc)) -> CalendarDetailFunc_WithClosures -> C_CalendarDetailFunc

Wrap a CalendarDetailFunc into a C_CalendarDetailFunc.

Callback

type C_Callback = Ptr Widget -> Ptr () -> IO ()

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

type Callback

Arguments

 = Widget

widget: the widget to operate on

-> IO ()

The type of the callback functions used for e.g. iterating over the children of a container, see containerForeach.

type Callback_WithClosures

Arguments

 = Widget

widget: the widget to operate on

-> Ptr ()

data: user-supplied data

-> IO ()

The type of the callback functions used for e.g. iterating over the children of a container, see containerForeach.

drop_closures_Callback :: Callback -> Callback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_Callback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_Callback

-> a

widget: the widget to operate on

-> Ptr ()

data: user-supplied data

-> m ()

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

genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)

Wrap the callback into a GClosure.

mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

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

noCallback :: Maybe Callback

A convenience synonym for Nothing :: Maybe Callback.

noCallback_WithClosures :: Maybe Callback_WithClosures

A convenience synonym for Nothing :: Maybe Callback_WithClosures.

wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback_WithClosures -> C_Callback

Wrap a Callback into a C_Callback.

CellAllocCallback

type C_CellAllocCallback = Ptr CellRenderer -> Ptr Rectangle -> Ptr Rectangle -> Ptr () -> IO CInt

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

type CellAllocCallback

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> Rectangle

cellArea: the area allocated to renderer inside the rectangle provided to cellAreaForeachAlloc.

-> Rectangle

cellBackground: the background area for renderer inside the background area provided to cellAreaForeachAlloc.

-> IO Bool

Returns: True to stop iterating over cells.

The type of the callback functions used for iterating over the cell renderers and their allocated areas inside a CellArea, see cellAreaForeachAlloc.

type CellAllocCallback_WithClosures

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> Rectangle

cellArea: the area allocated to renderer inside the rectangle provided to cellAreaForeachAlloc.

-> Rectangle

cellBackground: the background area for renderer inside the background area provided to cellAreaForeachAlloc.

-> Ptr ()

data: user-supplied data

-> IO Bool

Returns: True to stop iterating over cells.

The type of the callback functions used for iterating over the cell renderers and their allocated areas inside a CellArea, see cellAreaForeachAlloc.

drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CellAllocCallback

Arguments

:: (HasCallStack, MonadIO m, IsCellRenderer a)

=> FunPtr C_CellAllocCallback

-> a

renderer: the cell renderer to operate on

-> Rectangle

cellArea: the area allocated to renderer inside the rectangle provided to cellAreaForeachAlloc.

-> Rectangle

cellBackground: the background area for renderer inside the background area provided to cellAreaForeachAlloc.

-> Ptr ()

data: user-supplied data

-> m Bool

Returns: True to stop iterating over cells.

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

genClosure_CellAllocCallback :: MonadIO m => CellAllocCallback -> m (GClosure C_CellAllocCallback)

Wrap the callback into a GClosure.

mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback)

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

noCellAllocCallback :: Maybe CellAllocCallback

A convenience synonym for Nothing :: Maybe CellAllocCallback.

noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures

A convenience synonym for Nothing :: Maybe CellAllocCallback_WithClosures.

wrap_CellAllocCallback :: Maybe (Ptr (FunPtr C_CellAllocCallback)) -> CellAllocCallback_WithClosures -> C_CellAllocCallback

Wrap a CellAllocCallback into a C_CellAllocCallback.

CellCallback

type C_CellCallback = Ptr CellRenderer -> Ptr () -> IO CInt

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

type CellCallback

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> IO Bool

Returns: True to stop iterating over cells.

The type of the callback functions used for iterating over the cell renderers of a CellArea, see cellAreaForeach.

type CellCallback_WithClosures

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> Ptr ()

data: user-supplied data

-> IO Bool

Returns: True to stop iterating over cells.

The type of the callback functions used for iterating over the cell renderers of a CellArea, see cellAreaForeach.

drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CellCallback

Arguments

:: (HasCallStack, MonadIO m, IsCellRenderer a)

=> FunPtr C_CellCallback

-> a

renderer: the cell renderer to operate on

-> Ptr ()

data: user-supplied data

-> m Bool

Returns: True to stop iterating over cells.

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

genClosure_CellCallback :: MonadIO m => CellCallback -> m (GClosure C_CellCallback)

Wrap the callback into a GClosure.

mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback)

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

noCellCallback :: Maybe CellCallback

A convenience synonym for Nothing :: Maybe CellCallback.

noCellCallback_WithClosures :: Maybe CellCallback_WithClosures

A convenience synonym for Nothing :: Maybe CellCallback_WithClosures.

wrap_CellCallback :: Maybe (Ptr (FunPtr C_CellCallback)) -> CellCallback_WithClosures -> C_CellCallback

Wrap a CellCallback into a C_CellCallback.

CellLayoutDataFunc

type C_CellLayoutDataFunc = Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

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

type CellLayoutDataFunc

Arguments

 = CellLayout

cellLayout: a CellLayout

-> CellRenderer

cell: the cell renderer whose value is to be set

-> TreeModel

treeModel: the model

-> TreeIter

iter: a TreeIter indicating the row to set the value for

-> IO ()

A function which should set the value of cellLayout’s cell renderer(s) as appropriate.

type CellLayoutDataFunc_WithClosures

Arguments

 = CellLayout

cellLayout: a CellLayout

-> CellRenderer

cell: the cell renderer whose value is to be set

-> TreeModel

treeModel: the model

-> TreeIter

iter: a TreeIter indicating the row to set the value for

-> Ptr ()

data: user data passed to cellLayoutSetCellDataFunc

-> IO ()

A function which should set the value of cellLayout’s cell renderer(s) as appropriate.

drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CellLayoutDataFunc

Arguments

:: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b, IsTreeModel c)

=> FunPtr C_CellLayoutDataFunc

-> a

cellLayout: a CellLayout

-> b

cell: the cell renderer whose value is to be set

-> c

treeModel: the model

-> TreeIter

iter: a TreeIter indicating the row to set the value for

-> Ptr ()

data: user data passed to cellLayoutSetCellDataFunc

-> m ()

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

genClosure_CellLayoutDataFunc :: MonadIO m => CellLayoutDataFunc -> m (GClosure C_CellLayoutDataFunc)

Wrap the callback into a GClosure.

mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc)

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

noCellLayoutDataFunc :: Maybe CellLayoutDataFunc

A convenience synonym for Nothing :: Maybe CellLayoutDataFunc.

noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures

A convenience synonym for Nothing :: Maybe CellLayoutDataFunc_WithClosures.

wrap_CellLayoutDataFunc :: Maybe (Ptr (FunPtr C_CellLayoutDataFunc)) -> CellLayoutDataFunc_WithClosures -> C_CellLayoutDataFunc

Wrap a CellLayoutDataFunc into a C_CellLayoutDataFunc.

ClipboardClearFunc

type C_ClipboardClearFunc = Ptr Clipboard -> Ptr () -> IO ()

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

type ClipboardClearFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> Ptr ()

userDataOrOwner: the userData argument passed to gtk_clipboard_set_with_data(), or the owner argument passed to gtk_clipboard_set_with_owner()

-> IO ()

A function that will be called when the contents of the clipboard are changed or cleared. Once this has called, the userDataOrOwner argument will not be used again.

dynamic_ClipboardClearFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardClearFunc

-> a

clipboard: the Clipboard

-> Ptr ()

userDataOrOwner: the userData argument passed to gtk_clipboard_set_with_data(), or the owner argument passed to gtk_clipboard_set_with_owner()

-> m ()

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

genClosure_ClipboardClearFunc :: MonadIO m => ClipboardClearFunc -> m (GClosure C_ClipboardClearFunc)

Wrap the callback into a GClosure.

mk_ClipboardClearFunc :: C_ClipboardClearFunc -> IO (FunPtr C_ClipboardClearFunc)

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

noClipboardClearFunc :: Maybe ClipboardClearFunc

A convenience synonym for Nothing :: Maybe ClipboardClearFunc.

wrap_ClipboardClearFunc :: Maybe (Ptr (FunPtr C_ClipboardClearFunc)) -> ClipboardClearFunc -> C_ClipboardClearFunc

Wrap a ClipboardClearFunc into a C_ClipboardClearFunc.

ClipboardGetFunc

type C_ClipboardGetFunc = Ptr Clipboard -> Ptr SelectionData -> Word32 -> Ptr () -> IO ()

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

type ClipboardGetFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> SelectionData

selectionData: a SelectionData argument in which the requested data should be stored.

-> Word32

info: the info field corresponding to the requested target from the TargetEntry array passed to gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().

-> Ptr ()

userDataOrOwner: the userData argument passed to gtk_clipboard_set_with_data(), or the owner argument passed to gtk_clipboard_set_with_owner()

-> IO ()

A function that will be called to provide the contents of the selection. If multiple types of data were advertised, the requested type can be determined from the info parameter or by checking the target field of selectionData. If the data could successfully be converted into then it should be stored into the selectionData object by calling selectionDataSet (or related functions such as selectionDataSetText). If no data is set, the requestor will be informed that the attempt to get the data failed.

dynamic_ClipboardGetFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardGetFunc

-> a

clipboard: the Clipboard

-> SelectionData

selectionData: a SelectionData argument in which the requested data should be stored.

-> Word32

info: the info field corresponding to the requested target from the TargetEntry array passed to gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().

-> Ptr ()

userDataOrOwner: the userData argument passed to gtk_clipboard_set_with_data(), or the owner argument passed to gtk_clipboard_set_with_owner()

-> m ()

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

genClosure_ClipboardGetFunc :: MonadIO m => ClipboardGetFunc -> m (GClosure C_ClipboardGetFunc)

Wrap the callback into a GClosure.

mk_ClipboardGetFunc :: C_ClipboardGetFunc -> IO (FunPtr C_ClipboardGetFunc)

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

noClipboardGetFunc :: Maybe ClipboardGetFunc

A convenience synonym for Nothing :: Maybe ClipboardGetFunc.

wrap_ClipboardGetFunc :: Maybe (Ptr (FunPtr C_ClipboardGetFunc)) -> ClipboardGetFunc -> C_ClipboardGetFunc

Wrap a ClipboardGetFunc into a C_ClipboardGetFunc.

ClipboardImageReceivedFunc

type C_ClipboardImageReceivedFunc = Ptr Clipboard -> Ptr Pixbuf -> Ptr () -> IO ()

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

type ClipboardImageReceivedFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> Maybe Pixbuf

pixbuf: the received image

-> IO ()

A function to be called when the results of clipboardRequestImage are received, or when the request fails.

Since: 2.6

type ClipboardImageReceivedFunc_WithClosures

Arguments

 = Clipboard

clipboard: the Clipboard

-> Maybe Pixbuf

pixbuf: the received image

-> Ptr ()

data: the userData supplied to clipboardRequestImage.

-> IO ()

A function to be called when the results of clipboardRequestImage are received, or when the request fails.

Since: 2.6

drop_closures_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> ClipboardImageReceivedFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardImageReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b)

=> FunPtr C_ClipboardImageReceivedFunc

-> a

clipboard: the Clipboard

-> Maybe b

pixbuf: the received image

-> Ptr ()

data: the userData supplied to clipboardRequestImage.

-> m ()

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

genClosure_ClipboardImageReceivedFunc :: MonadIO m => ClipboardImageReceivedFunc -> m (GClosure C_ClipboardImageReceivedFunc)

Wrap the callback into a GClosure.

mk_ClipboardImageReceivedFunc :: C_ClipboardImageReceivedFunc -> IO (FunPtr C_ClipboardImageReceivedFunc)

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

noClipboardImageReceivedFunc :: Maybe ClipboardImageReceivedFunc

A convenience synonym for Nothing :: Maybe ClipboardImageReceivedFunc.

noClipboardImageReceivedFunc_WithClosures :: Maybe ClipboardImageReceivedFunc_WithClosures

A convenience synonym for Nothing :: Maybe ClipboardImageReceivedFunc_WithClosures.

wrap_ClipboardImageReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardImageReceivedFunc)) -> ClipboardImageReceivedFunc_WithClosures -> C_ClipboardImageReceivedFunc

Wrap a ClipboardImageReceivedFunc into a C_ClipboardImageReceivedFunc.

ClipboardReceivedFunc

type C_ClipboardReceivedFunc = Ptr Clipboard -> Ptr SelectionData -> Ptr () -> IO ()

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

type ClipboardReceivedFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> SelectionData

selectionData: a SelectionData containing the data was received. If retrieving the data failed, then then length field of selectionData will be negative.

-> IO ()

A function to be called when the results of clipboardRequestContents are received, or when the request fails.

type ClipboardReceivedFunc_WithClosures

Arguments

 = Clipboard

clipboard: the Clipboard

-> SelectionData

selectionData: a SelectionData containing the data was received. If retrieving the data failed, then then length field of selectionData will be negative.

-> Ptr ()

data: the userData supplied to clipboardRequestContents.

-> IO ()

A function to be called when the results of clipboardRequestContents are received, or when the request fails.

drop_closures_ClipboardReceivedFunc :: ClipboardReceivedFunc -> ClipboardReceivedFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardReceivedFunc

-> a

clipboard: the Clipboard

-> SelectionData

selectionData: a SelectionData containing the data was received. If retrieving the data failed, then then length field of selectionData will be negative.

-> Ptr ()

data: the userData supplied to clipboardRequestContents.

-> m ()

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

genClosure_ClipboardReceivedFunc :: MonadIO m => ClipboardReceivedFunc -> m (GClosure C_ClipboardReceivedFunc)

Wrap the callback into a GClosure.

mk_ClipboardReceivedFunc :: C_ClipboardReceivedFunc -> IO (FunPtr C_ClipboardReceivedFunc)

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

noClipboardReceivedFunc :: Maybe ClipboardReceivedFunc

A convenience synonym for Nothing :: Maybe ClipboardReceivedFunc.

noClipboardReceivedFunc_WithClosures :: Maybe ClipboardReceivedFunc_WithClosures

A convenience synonym for Nothing :: Maybe ClipboardReceivedFunc_WithClosures.

wrap_ClipboardReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardReceivedFunc)) -> ClipboardReceivedFunc_WithClosures -> C_ClipboardReceivedFunc

Wrap a ClipboardReceivedFunc into a C_ClipboardReceivedFunc.

ClipboardRichTextReceivedFunc

type C_ClipboardRichTextReceivedFunc = Ptr Clipboard -> Ptr Atom -> CString -> Word64 -> Ptr () -> IO ()

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

type ClipboardRichTextReceivedFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> Atom

format: The format of the rich text

-> Maybe Text

text: the rich text received, as a UTF-8 encoded string, or Nothing if retrieving the data failed.

-> Word64

length: Length of the text.

-> IO ()

A function to be called when the results of clipboardRequestRichText are received, or when the request fails.

Since: 2.10

type ClipboardRichTextReceivedFunc_WithClosures

Arguments

 = Clipboard

clipboard: the Clipboard

-> Atom

format: The format of the rich text

-> Maybe Text

text: the rich text received, as a UTF-8 encoded string, or Nothing if retrieving the data failed.

-> Word64

length: Length of the text.

-> Ptr ()

data: the userData supplied to clipboardRequestRichText.

-> IO ()

A function to be called when the results of clipboardRequestRichText are received, or when the request fails.

Since: 2.10

drop_closures_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> ClipboardRichTextReceivedFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardRichTextReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardRichTextReceivedFunc

-> a

clipboard: the Clipboard

-> Atom

format: The format of the rich text

-> Maybe Text

text: the rich text received, as a UTF-8 encoded string, or Nothing if retrieving the data failed.

-> Word64

length: Length of the text.

-> Ptr ()

data: the userData supplied to clipboardRequestRichText.

-> m ()

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

genClosure_ClipboardRichTextReceivedFunc :: MonadIO m => ClipboardRichTextReceivedFunc -> m (GClosure C_ClipboardRichTextReceivedFunc)

Wrap the callback into a GClosure.

mk_ClipboardRichTextReceivedFunc :: C_ClipboardRichTextReceivedFunc -> IO (FunPtr C_ClipboardRichTextReceivedFunc)

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

noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc

A convenience synonym for Nothing :: Maybe ClipboardRichTextReceivedFunc.

noClipboardRichTextReceivedFunc_WithClosures :: Maybe ClipboardRichTextReceivedFunc_WithClosures

A convenience synonym for Nothing :: Maybe ClipboardRichTextReceivedFunc_WithClosures.

wrap_ClipboardRichTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardRichTextReceivedFunc)) -> ClipboardRichTextReceivedFunc_WithClosures -> C_ClipboardRichTextReceivedFunc

Wrap a ClipboardRichTextReceivedFunc into a C_ClipboardRichTextReceivedFunc.

ClipboardTargetsReceivedFunc

type C_ClipboardTargetsReceivedFunc = Ptr Clipboard -> Ptr (Ptr Atom) -> Int32 -> Ptr () -> IO ()

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

type ClipboardTargetsReceivedFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> Maybe [Atom]

atoms: the supported targets, as array of Atom, or Nothing if retrieving the data failed.

-> IO ()

A function to be called when the results of clipboardRequestTargets are received, or when the request fails.

Since: 2.4

type ClipboardTargetsReceivedFunc_WithClosures

Arguments

 = Clipboard

clipboard: the Clipboard

-> Maybe [Atom]

atoms: the supported targets, as array of Atom, or Nothing if retrieving the data failed.

-> Ptr ()

data: the userData supplied to clipboardRequestTargets.

-> IO ()

A function to be called when the results of clipboardRequestTargets are received, or when the request fails.

Since: 2.4

drop_closures_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> ClipboardTargetsReceivedFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardTargetsReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardTargetsReceivedFunc

-> a

clipboard: the Clipboard

-> Maybe [Atom]

atoms: the supported targets, as array of Atom, or Nothing if retrieving the data failed.

-> Ptr ()

data: the userData supplied to clipboardRequestTargets.

-> m ()

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

genClosure_ClipboardTargetsReceivedFunc :: MonadIO m => ClipboardTargetsReceivedFunc -> m (GClosure C_ClipboardTargetsReceivedFunc)

Wrap the callback into a GClosure.

mk_ClipboardTargetsReceivedFunc :: C_ClipboardTargetsReceivedFunc -> IO (FunPtr C_ClipboardTargetsReceivedFunc)

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

noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc

A convenience synonym for Nothing :: Maybe ClipboardTargetsReceivedFunc.

noClipboardTargetsReceivedFunc_WithClosures :: Maybe ClipboardTargetsReceivedFunc_WithClosures

A convenience synonym for Nothing :: Maybe ClipboardTargetsReceivedFunc_WithClosures.

wrap_ClipboardTargetsReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTargetsReceivedFunc)) -> ClipboardTargetsReceivedFunc_WithClosures -> C_ClipboardTargetsReceivedFunc

Wrap a ClipboardTargetsReceivedFunc into a C_ClipboardTargetsReceivedFunc.

ClipboardTextReceivedFunc

type C_ClipboardTextReceivedFunc = Ptr Clipboard -> CString -> Ptr () -> IO ()

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

type ClipboardTextReceivedFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> Maybe Text

text: the text received, as a UTF-8 encoded string, or Nothing if retrieving the data failed.

-> IO ()

A function to be called when the results of clipboardRequestText are received, or when the request fails.

type ClipboardTextReceivedFunc_WithClosures

Arguments

 = Clipboard

clipboard: the Clipboard

-> Maybe Text

text: the text received, as a UTF-8 encoded string, or Nothing if retrieving the data failed.

-> Ptr ()

data: the userData supplied to clipboardRequestText.

-> IO ()

A function to be called when the results of clipboardRequestText are received, or when the request fails.

drop_closures_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> ClipboardTextReceivedFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardTextReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardTextReceivedFunc

-> a

clipboard: the Clipboard

-> Maybe Text

text: the text received, as a UTF-8 encoded string, or Nothing if retrieving the data failed.

-> Ptr ()

data: the userData supplied to clipboardRequestText.

-> m ()

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

genClosure_ClipboardTextReceivedFunc :: MonadIO m => ClipboardTextReceivedFunc -> m (GClosure C_ClipboardTextReceivedFunc)

Wrap the callback into a GClosure.

mk_ClipboardTextReceivedFunc :: C_ClipboardTextReceivedFunc -> IO (FunPtr C_ClipboardTextReceivedFunc)

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

noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc

A convenience synonym for Nothing :: Maybe ClipboardTextReceivedFunc.

noClipboardTextReceivedFunc_WithClosures :: Maybe ClipboardTextReceivedFunc_WithClosures

A convenience synonym for Nothing :: Maybe ClipboardTextReceivedFunc_WithClosures.

wrap_ClipboardTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTextReceivedFunc)) -> ClipboardTextReceivedFunc_WithClosures -> C_ClipboardTextReceivedFunc

Wrap a ClipboardTextReceivedFunc into a C_ClipboardTextReceivedFunc.

ClipboardURIReceivedFunc

type C_ClipboardURIReceivedFunc = Ptr Clipboard -> Ptr CString -> Ptr () -> IO ()

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

type ClipboardURIReceivedFunc

Arguments

 = Clipboard

clipboard: the Clipboard

-> [Text]

uris: the received URIs

-> IO ()

A function to be called when the results of clipboardRequestUris are received, or when the request fails.

Since: 2.14

type ClipboardURIReceivedFunc_WithClosures

Arguments

 = Clipboard

clipboard: the Clipboard

-> [Text]

uris: the received URIs

-> Ptr ()

data: the userData supplied to clipboardRequestUris.

-> IO ()

A function to be called when the results of clipboardRequestUris are received, or when the request fails.

Since: 2.14

drop_closures_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> ClipboardURIReceivedFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardURIReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardURIReceivedFunc

-> a

clipboard: the Clipboard

-> [Text]

uris: the received URIs

-> Ptr ()

data: the userData supplied to clipboardRequestUris.

-> m ()

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

genClosure_ClipboardURIReceivedFunc :: MonadIO m => ClipboardURIReceivedFunc -> m (GClosure C_ClipboardURIReceivedFunc)

Wrap the callback into a GClosure.

mk_ClipboardURIReceivedFunc :: C_ClipboardURIReceivedFunc -> IO (FunPtr C_ClipboardURIReceivedFunc)

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

noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc

A convenience synonym for Nothing :: Maybe ClipboardURIReceivedFunc.

noClipboardURIReceivedFunc_WithClosures :: Maybe ClipboardURIReceivedFunc_WithClosures

A convenience synonym for Nothing :: Maybe ClipboardURIReceivedFunc_WithClosures.

wrap_ClipboardURIReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardURIReceivedFunc)) -> ClipboardURIReceivedFunc_WithClosures -> C_ClipboardURIReceivedFunc

Wrap a ClipboardURIReceivedFunc into a C_ClipboardURIReceivedFunc.

ColorSelectionChangePaletteFunc

type C_ColorSelectionChangePaletteFunc = Ptr Color -> Int32 -> IO ()

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

type ColorSelectionChangePaletteFunc

Arguments

 = [Color]

colors: Array of colors

-> IO ()

Deprecated: (Since version 3.4)

No description available in the introspection data.

dynamic_ColorSelectionChangePaletteFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ColorSelectionChangePaletteFunc

-> [Color]

colors: Array of colors

-> m ()

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

genClosure_ColorSelectionChangePaletteFunc :: MonadIO m => ColorSelectionChangePaletteFunc -> m (GClosure C_ColorSelectionChangePaletteFunc)

Wrap the callback into a GClosure.

mk_ColorSelectionChangePaletteFunc :: C_ColorSelectionChangePaletteFunc -> IO (FunPtr C_ColorSelectionChangePaletteFunc)

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

noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc

A convenience synonym for Nothing :: Maybe ColorSelectionChangePaletteFunc.

wrap_ColorSelectionChangePaletteFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteFunc)) -> ColorSelectionChangePaletteFunc -> C_ColorSelectionChangePaletteFunc

Wrap a ColorSelectionChangePaletteFunc into a C_ColorSelectionChangePaletteFunc.

ColorSelectionChangePaletteWithScreenFunc

type C_ColorSelectionChangePaletteWithScreenFunc = Ptr Screen -> Ptr Color -> Int32 -> IO ()

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

type ColorSelectionChangePaletteWithScreenFunc

Arguments

 = Screen

-> [Color]

colors: Array of colors

-> IO ()

Deprecated: (Since version 3.4)

No description available in the introspection data.

Since: 2.2

dynamic_ColorSelectionChangePaletteWithScreenFunc

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> FunPtr C_ColorSelectionChangePaletteWithScreenFunc

-> a

-> [Color]

colors: Array of colors

-> m ()

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

genClosure_ColorSelectionChangePaletteWithScreenFunc :: MonadIO m => ColorSelectionChangePaletteWithScreenFunc -> m (GClosure C_ColorSelectionChangePaletteWithScreenFunc)

Wrap the callback into a GClosure.

mk_ColorSelectionChangePaletteWithScreenFunc :: C_ColorSelectionChangePaletteWithScreenFunc -> IO (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)

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

noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc

A convenience synonym for Nothing :: Maybe ColorSelectionChangePaletteWithScreenFunc.

wrap_ColorSelectionChangePaletteWithScreenFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)) -> ColorSelectionChangePaletteWithScreenFunc -> C_ColorSelectionChangePaletteWithScreenFunc

Wrap a ColorSelectionChangePaletteWithScreenFunc into a C_ColorSelectionChangePaletteWithScreenFunc.

ContainerClassAddFieldCallback

type C_ContainerClassAddFieldCallback = Ptr Container -> Ptr Widget -> IO ()

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

type ContainerClassAddFieldCallback

Arguments

 = Container

container: a Container

-> Widget

widget: a widget to be placed inside container

-> IO ()

No description available in the introspection data.

dynamic_ContainerClassAddFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b)

=> FunPtr C_ContainerClassAddFieldCallback

-> a

container: a Container

-> b

widget: a widget to be placed inside container

-> m ()

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

genClosure_ContainerClassAddFieldCallback :: MonadIO m => ContainerClassAddFieldCallback -> m (GClosure C_ContainerClassAddFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassAddFieldCallback :: C_ContainerClassAddFieldCallback -> IO (FunPtr C_ContainerClassAddFieldCallback)

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

noContainerClassAddFieldCallback :: Maybe ContainerClassAddFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassAddFieldCallback.

wrap_ContainerClassAddFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassAddFieldCallback)) -> ContainerClassAddFieldCallback -> C_ContainerClassAddFieldCallback

Wrap a ContainerClassAddFieldCallback into a C_ContainerClassAddFieldCallback.

ContainerClassCheckResizeFieldCallback

type C_ContainerClassCheckResizeFieldCallback = Ptr Container -> IO ()

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

type ContainerClassCheckResizeFieldCallback = Container -> IO ()

No description available in the introspection data.

dynamic_ContainerClassCheckResizeFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassCheckResizeFieldCallback -> a -> m ()

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

genClosure_ContainerClassCheckResizeFieldCallback :: MonadIO m => ContainerClassCheckResizeFieldCallback -> m (GClosure C_ContainerClassCheckResizeFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassCheckResizeFieldCallback :: C_ContainerClassCheckResizeFieldCallback -> IO (FunPtr C_ContainerClassCheckResizeFieldCallback)

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

noContainerClassCheckResizeFieldCallback :: Maybe ContainerClassCheckResizeFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassCheckResizeFieldCallback.

wrap_ContainerClassCheckResizeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)) -> ContainerClassCheckResizeFieldCallback -> C_ContainerClassCheckResizeFieldCallback

Wrap a ContainerClassCheckResizeFieldCallback into a C_ContainerClassCheckResizeFieldCallback.

ContainerClassChildTypeFieldCallback

type C_ContainerClassChildTypeFieldCallback = Ptr Container -> IO CGType

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

type ContainerClassChildTypeFieldCallback

Arguments

 = Container

container: a Container

-> IO GType

Returns: a GType.

No description available in the introspection data.

dynamic_ContainerClassChildTypeFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsContainer a)

=> FunPtr C_ContainerClassChildTypeFieldCallback

-> a

container: a Container

-> m GType

Returns: a GType.

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

genClosure_ContainerClassChildTypeFieldCallback :: MonadIO m => ContainerClassChildTypeFieldCallback -> m (GClosure C_ContainerClassChildTypeFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassChildTypeFieldCallback :: C_ContainerClassChildTypeFieldCallback -> IO (FunPtr C_ContainerClassChildTypeFieldCallback)

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

noContainerClassChildTypeFieldCallback :: Maybe ContainerClassChildTypeFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassChildTypeFieldCallback.

wrap_ContainerClassChildTypeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)) -> ContainerClassChildTypeFieldCallback -> C_ContainerClassChildTypeFieldCallback

Wrap a ContainerClassChildTypeFieldCallback into a C_ContainerClassChildTypeFieldCallback.

ContainerClassCompositeNameFieldCallback

type C_ContainerClassCompositeNameFieldCallback = Ptr Container -> Ptr Widget -> IO CString

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

type ContainerClassCompositeNameFieldCallback = Container -> Widget -> IO Text

No description available in the introspection data.

dynamic_ContainerClassCompositeNameFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassCompositeNameFieldCallback -> a -> b -> m Text

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

genClosure_ContainerClassCompositeNameFieldCallback :: MonadIO m => ContainerClassCompositeNameFieldCallback -> m (GClosure C_ContainerClassCompositeNameFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassCompositeNameFieldCallback :: C_ContainerClassCompositeNameFieldCallback -> IO (FunPtr C_ContainerClassCompositeNameFieldCallback)

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

noContainerClassCompositeNameFieldCallback :: Maybe ContainerClassCompositeNameFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassCompositeNameFieldCallback.

wrap_ContainerClassCompositeNameFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)) -> ContainerClassCompositeNameFieldCallback -> C_ContainerClassCompositeNameFieldCallback

Wrap a ContainerClassCompositeNameFieldCallback into a C_ContainerClassCompositeNameFieldCallback.

ContainerClassForallFieldCallback

type C_ContainerClassForallFieldCallback = Ptr Container -> CInt -> FunPtr C_Callback -> Ptr () -> IO ()

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

type ContainerClassForallFieldCallback

Arguments

 = Container

container: a Container

-> Bool

-> Callback_WithClosures

callback: a callback

-> IO ()

No description available in the introspection data.

type ContainerClassForallFieldCallback_WithClosures

Arguments

 = Container

container: a Container

-> Bool

-> Callback_WithClosures

callback: a callback

-> Ptr ()

callbackData: callback user data

-> IO ()

No description available in the introspection data.

drop_closures_ContainerClassForallFieldCallback :: ContainerClassForallFieldCallback -> ContainerClassForallFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ContainerClassForallFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsContainer a)

=> FunPtr C_ContainerClassForallFieldCallback

-> a

container: a Container

-> Bool

-> Callback_WithClosures

callback: a callback

-> Ptr ()

callbackData: callback user data

-> m ()

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

genClosure_ContainerClassForallFieldCallback :: MonadIO m => ContainerClassForallFieldCallback -> m (GClosure C_ContainerClassForallFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassForallFieldCallback :: C_ContainerClassForallFieldCallback -> IO (FunPtr C_ContainerClassForallFieldCallback)

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

noContainerClassForallFieldCallback :: Maybe ContainerClassForallFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassForallFieldCallback.

noContainerClassForallFieldCallback_WithClosures :: Maybe ContainerClassForallFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe ContainerClassForallFieldCallback_WithClosures.

wrap_ContainerClassForallFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassForallFieldCallback)) -> ContainerClassForallFieldCallback_WithClosures -> C_ContainerClassForallFieldCallback

Wrap a ContainerClassForallFieldCallback into a C_ContainerClassForallFieldCallback.

ContainerClassGetChildPropertyFieldCallback

type C_ContainerClassGetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

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

type ContainerClassGetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO ()

No description available in the introspection data.

dynamic_ContainerClassGetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassGetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()

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

genClosure_ContainerClassGetChildPropertyFieldCallback :: MonadIO m => ContainerClassGetChildPropertyFieldCallback -> m (GClosure C_ContainerClassGetChildPropertyFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassGetChildPropertyFieldCallback :: C_ContainerClassGetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassGetChildPropertyFieldCallback)

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

noContainerClassGetChildPropertyFieldCallback :: Maybe ContainerClassGetChildPropertyFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassGetChildPropertyFieldCallback.

wrap_ContainerClassGetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetChildPropertyFieldCallback)) -> ContainerClassGetChildPropertyFieldCallback -> C_ContainerClassGetChildPropertyFieldCallback

Wrap a ContainerClassGetChildPropertyFieldCallback into a C_ContainerClassGetChildPropertyFieldCallback.

ContainerClassGetPathForChildFieldCallback

type C_ContainerClassGetPathForChildFieldCallback = Ptr Container -> Ptr Widget -> IO (Ptr WidgetPath)

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

type ContainerClassGetPathForChildFieldCallback

Arguments

 = Container

container: a Container

-> Widget

child: a child of container

-> IO WidgetPath

Returns: A newly created WidgetPath

No description available in the introspection data.

dynamic_ContainerClassGetPathForChildFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b)

=> FunPtr C_ContainerClassGetPathForChildFieldCallback

-> a

container: a Container

-> b

child: a child of container

-> m WidgetPath

Returns: A newly created WidgetPath

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

genClosure_ContainerClassGetPathForChildFieldCallback :: MonadIO m => ContainerClassGetPathForChildFieldCallback -> m (GClosure C_ContainerClassGetPathForChildFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassGetPathForChildFieldCallback :: C_ContainerClassGetPathForChildFieldCallback -> IO (FunPtr C_ContainerClassGetPathForChildFieldCallback)

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

noContainerClassGetPathForChildFieldCallback :: Maybe ContainerClassGetPathForChildFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassGetPathForChildFieldCallback.

wrap_ContainerClassGetPathForChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)) -> ContainerClassGetPathForChildFieldCallback -> C_ContainerClassGetPathForChildFieldCallback

Wrap a ContainerClassGetPathForChildFieldCallback into a C_ContainerClassGetPathForChildFieldCallback.

ContainerClassRemoveFieldCallback

type C_ContainerClassRemoveFieldCallback = Ptr Container -> Ptr Widget -> IO ()

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

type ContainerClassRemoveFieldCallback

Arguments

 = Container

container: a Container

-> Widget

widget: a current child of container

-> IO ()

No description available in the introspection data.

dynamic_ContainerClassRemoveFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b)

=> FunPtr C_ContainerClassRemoveFieldCallback

-> a

container: a Container

-> b

widget: a current child of container

-> m ()

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

genClosure_ContainerClassRemoveFieldCallback :: MonadIO m => ContainerClassRemoveFieldCallback -> m (GClosure C_ContainerClassRemoveFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassRemoveFieldCallback :: C_ContainerClassRemoveFieldCallback -> IO (FunPtr C_ContainerClassRemoveFieldCallback)

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

noContainerClassRemoveFieldCallback :: Maybe ContainerClassRemoveFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassRemoveFieldCallback.

wrap_ContainerClassRemoveFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassRemoveFieldCallback)) -> ContainerClassRemoveFieldCallback -> C_ContainerClassRemoveFieldCallback

Wrap a ContainerClassRemoveFieldCallback into a C_ContainerClassRemoveFieldCallback.

ContainerClassSetChildPropertyFieldCallback

type C_ContainerClassSetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

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

type ContainerClassSetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO ()

No description available in the introspection data.

dynamic_ContainerClassSetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassSetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()

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

genClosure_ContainerClassSetChildPropertyFieldCallback :: MonadIO m => ContainerClassSetChildPropertyFieldCallback -> m (GClosure C_ContainerClassSetChildPropertyFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassSetChildPropertyFieldCallback :: C_ContainerClassSetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)

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

noContainerClassSetChildPropertyFieldCallback :: Maybe ContainerClassSetChildPropertyFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassSetChildPropertyFieldCallback.

wrap_ContainerClassSetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)) -> ContainerClassSetChildPropertyFieldCallback -> C_ContainerClassSetChildPropertyFieldCallback

Wrap a ContainerClassSetChildPropertyFieldCallback into a C_ContainerClassSetChildPropertyFieldCallback.

ContainerClassSetFocusChildFieldCallback

type C_ContainerClassSetFocusChildFieldCallback = Ptr Container -> Ptr Widget -> IO ()

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

type ContainerClassSetFocusChildFieldCallback

Arguments

 = Container

container: a Container

-> Maybe Widget

child: a Widget, or Nothing

-> IO ()

No description available in the introspection data.

dynamic_ContainerClassSetFocusChildFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b)

=> FunPtr C_ContainerClassSetFocusChildFieldCallback

-> a

container: a Container

-> Maybe b

child: a Widget, or Nothing

-> m ()

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

genClosure_ContainerClassSetFocusChildFieldCallback :: MonadIO m => ContainerClassSetFocusChildFieldCallback -> m (GClosure C_ContainerClassSetFocusChildFieldCallback)

Wrap the callback into a GClosure.

mk_ContainerClassSetFocusChildFieldCallback :: C_ContainerClassSetFocusChildFieldCallback -> IO (FunPtr C_ContainerClassSetFocusChildFieldCallback)

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

noContainerClassSetFocusChildFieldCallback :: Maybe ContainerClassSetFocusChildFieldCallback

A convenience synonym for Nothing :: Maybe ContainerClassSetFocusChildFieldCallback.

wrap_ContainerClassSetFocusChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetFocusChildFieldCallback)) -> ContainerClassSetFocusChildFieldCallback -> C_ContainerClassSetFocusChildFieldCallback

Wrap a ContainerClassSetFocusChildFieldCallback into a C_ContainerClassSetFocusChildFieldCallback.

EntryCompletionMatchFunc

type C_EntryCompletionMatchFunc = Ptr EntryCompletion -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

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

type EntryCompletionMatchFunc

Arguments

 = EntryCompletion

completion: the EntryCompletion

-> Text

key: the string to match, normalized and case-folded

-> TreeIter

iter: a TreeIter indicating the row to match

-> IO Bool

Returns: True if iter should be displayed as a possible completion for key

A function which decides whether the row indicated by iter matches a given key, and should be displayed as a possible completion for key. Note that key is normalized and case-folded (see utf8Normalize and utf8Casefold). If this is not appropriate, match functions have access to the unmodified key via gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ())).

type EntryCompletionMatchFunc_WithClosures

Arguments

 = EntryCompletion

completion: the EntryCompletion

-> Text

key: the string to match, normalized and case-folded

-> TreeIter

iter: a TreeIter indicating the row to match

-> Ptr ()

userData: user data given to entryCompletionSetMatchFunc

-> IO Bool

Returns: True if iter should be displayed as a possible completion for key

A function which decides whether the row indicated by iter matches a given key, and should be displayed as a possible completion for key. Note that key is normalized and case-folded (see utf8Normalize and utf8Casefold). If this is not appropriate, match functions have access to the unmodified key via gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ())).

drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_EntryCompletionMatchFunc

Arguments

:: (HasCallStack, MonadIO m, IsEntryCompletion a)

=> FunPtr C_EntryCompletionMatchFunc

-> a

completion: the EntryCompletion

-> Text

key: the string to match, normalized and case-folded

-> TreeIter

iter: a TreeIter indicating the row to match

-> Ptr ()

userData: user data given to entryCompletionSetMatchFunc

-> m Bool

Returns: True if iter should be displayed as a possible completion for key

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

genClosure_EntryCompletionMatchFunc :: MonadIO m => EntryCompletionMatchFunc -> m (GClosure C_EntryCompletionMatchFunc)

Wrap the callback into a GClosure.

mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc)

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

noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc

A convenience synonym for Nothing :: Maybe EntryCompletionMatchFunc.

noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures

A convenience synonym for Nothing :: Maybe EntryCompletionMatchFunc_WithClosures.

wrap_EntryCompletionMatchFunc :: Maybe (Ptr (FunPtr C_EntryCompletionMatchFunc)) -> EntryCompletionMatchFunc_WithClosures -> C_EntryCompletionMatchFunc

Wrap a EntryCompletionMatchFunc into a C_EntryCompletionMatchFunc.

FileFilterFunc

type C_FileFilterFunc = Ptr FileFilterInfo -> Ptr () -> IO CInt

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

type FileFilterFunc

Arguments

 = FileFilterInfo

filterInfo: a FileFilterInfo that is filled according to the needed flags passed to fileFilterAddCustom

-> IO Bool

Returns: True if the file should be displayed

The type of function that is used with custom filters, see fileFilterAddCustom.

type FileFilterFunc_WithClosures

Arguments

 = FileFilterInfo

filterInfo: a FileFilterInfo that is filled according to the needed flags passed to fileFilterAddCustom

-> Ptr ()

data: user data passed to fileFilterAddCustom

-> IO Bool

Returns: True if the file should be displayed

The type of function that is used with custom filters, see fileFilterAddCustom.

drop_closures_FileFilterFunc :: FileFilterFunc -> FileFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_FileFilterFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_FileFilterFunc

-> FileFilterInfo

filterInfo: a FileFilterInfo that is filled according to the needed flags passed to fileFilterAddCustom

-> Ptr ()

data: user data passed to fileFilterAddCustom

-> m Bool

Returns: True if the file should be displayed

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

genClosure_FileFilterFunc :: MonadIO m => FileFilterFunc -> m (GClosure C_FileFilterFunc)

Wrap the callback into a GClosure.

mk_FileFilterFunc :: C_FileFilterFunc -> IO (FunPtr C_FileFilterFunc)

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

noFileFilterFunc :: Maybe FileFilterFunc

A convenience synonym for Nothing :: Maybe FileFilterFunc.

noFileFilterFunc_WithClosures :: Maybe FileFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe FileFilterFunc_WithClosures.

wrap_FileFilterFunc :: Maybe (Ptr (FunPtr C_FileFilterFunc)) -> FileFilterFunc_WithClosures -> C_FileFilterFunc

Wrap a FileFilterFunc into a C_FileFilterFunc.

FlowBoxCreateWidgetFunc

type C_FlowBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO (Ptr Widget)

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

type FlowBoxCreateWidgetFunc

Arguments

 = Maybe Object

item: the item from the model for which to create a widget for

-> IO Widget

Returns: a Widget that represents item

Called for flow boxes that are bound to a ListModel with flowBoxBindModel for each item that gets added to the model.

Since: 3.18

type FlowBoxCreateWidgetFunc_WithClosures

Arguments

 = Maybe Object

item: the item from the model for which to create a widget for

-> Ptr ()

userData: user data from flowBoxBindModel

-> IO Widget

Returns: a Widget that represents item

Called for flow boxes that are bound to a ListModel with flowBoxBindModel for each item that gets added to the model.

Since: 3.18

drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxCreateWidgetFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_FlowBoxCreateWidgetFunc

-> Maybe a

item: the item from the model for which to create a widget for

-> Ptr ()

userData: user data from flowBoxBindModel

-> m Widget

Returns: a Widget that represents item

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

genClosure_FlowBoxCreateWidgetFunc :: MonadIO m => FlowBoxCreateWidgetFunc -> m (GClosure C_FlowBoxCreateWidgetFunc)

Wrap the callback into a GClosure.

mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc)

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

noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc

A convenience synonym for Nothing :: Maybe FlowBoxCreateWidgetFunc.

noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures

A convenience synonym for Nothing :: Maybe FlowBoxCreateWidgetFunc_WithClosures.

wrap_FlowBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_FlowBoxCreateWidgetFunc)) -> FlowBoxCreateWidgetFunc_WithClosures -> C_FlowBoxCreateWidgetFunc

Wrap a FlowBoxCreateWidgetFunc into a C_FlowBoxCreateWidgetFunc.

FlowBoxFilterFunc

type C_FlowBoxFilterFunc = Ptr FlowBoxChild -> Ptr () -> IO CInt

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

type FlowBoxFilterFunc

Arguments

 = FlowBoxChild

child: a FlowBoxChild that may be filtered

-> IO Bool

Returns: True if the row should be visible, False otherwise

A function that will be called whenrever a child changes or is added. It lets you control if the child should be visible or not.

Since: 3.12

type FlowBoxFilterFunc_WithClosures

Arguments

 = FlowBoxChild

child: a FlowBoxChild that may be filtered

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the row should be visible, False otherwise

A function that will be called whenrever a child changes or is added. It lets you control if the child should be visible or not.

Since: 3.12

drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxFilterFunc

Arguments

:: (HasCallStack, MonadIO m, IsFlowBoxChild a)

=> FunPtr C_FlowBoxFilterFunc

-> a

child: a FlowBoxChild that may be filtered

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the row should be visible, False otherwise

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

genClosure_FlowBoxFilterFunc :: MonadIO m => FlowBoxFilterFunc -> m (GClosure C_FlowBoxFilterFunc)

Wrap the callback into a GClosure.

mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc)

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

noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc

A convenience synonym for Nothing :: Maybe FlowBoxFilterFunc.

noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe FlowBoxFilterFunc_WithClosures.

wrap_FlowBoxFilterFunc :: Maybe (Ptr (FunPtr C_FlowBoxFilterFunc)) -> FlowBoxFilterFunc_WithClosures -> C_FlowBoxFilterFunc

Wrap a FlowBoxFilterFunc into a C_FlowBoxFilterFunc.

FlowBoxForeachFunc

type C_FlowBoxForeachFunc = Ptr FlowBox -> Ptr FlowBoxChild -> Ptr () -> IO ()

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

type FlowBoxForeachFunc

Arguments

 = FlowBox

box: a FlowBox

-> FlowBoxChild

child: a FlowBoxChild

-> IO ()

A function used by flowBoxSelectedForeach. It will be called on every selected child of the box.

Since: 3.12

type FlowBoxForeachFunc_WithClosures

Arguments

 = FlowBox

box: a FlowBox

-> FlowBoxChild

child: a FlowBoxChild

-> Ptr ()

userData: user data

-> IO ()

A function used by flowBoxSelectedForeach. It will be called on every selected child of the box.

Since: 3.12

drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b)

=> FunPtr C_FlowBoxForeachFunc

-> a

box: a FlowBox

-> b

child: a FlowBoxChild

-> Ptr ()

userData: user data

-> m ()

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

genClosure_FlowBoxForeachFunc :: MonadIO m => FlowBoxForeachFunc -> m (GClosure C_FlowBoxForeachFunc)

Wrap the callback into a GClosure.

mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc)

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

noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc

A convenience synonym for Nothing :: Maybe FlowBoxForeachFunc.

noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe FlowBoxForeachFunc_WithClosures.

wrap_FlowBoxForeachFunc :: Maybe (Ptr (FunPtr C_FlowBoxForeachFunc)) -> FlowBoxForeachFunc_WithClosures -> C_FlowBoxForeachFunc

Wrap a FlowBoxForeachFunc into a C_FlowBoxForeachFunc.

FlowBoxSortFunc

type C_FlowBoxSortFunc = Ptr FlowBoxChild -> Ptr FlowBoxChild -> Ptr () -> IO Int32

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

type FlowBoxSortFunc

Arguments

 = FlowBoxChild

child1: the first child

-> FlowBoxChild

child2: the second child

-> IO Int32

Returns: < 0 if child1 should be before child2, 0 if the are equal, and > 0 otherwise

A function to compare two children to determine which should come first.

Since: 3.12

type FlowBoxSortFunc_WithClosures

Arguments

 = FlowBoxChild

child1: the first child

-> FlowBoxChild

child2: the second child

-> Ptr ()

userData: user data

-> IO Int32

Returns: < 0 if child1 should be before child2, 0 if the are equal, and > 0 otherwise

A function to compare two children to determine which should come first.

Since: 3.12

drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxSortFunc

Arguments

:: (HasCallStack, MonadIO m, IsFlowBoxChild a, IsFlowBoxChild b)

=> FunPtr C_FlowBoxSortFunc

-> a

child1: the first child

-> b

child2: the second child

-> Ptr ()

userData: user data

-> m Int32

Returns: < 0 if child1 should be before child2, 0 if the are equal, and > 0 otherwise

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

genClosure_FlowBoxSortFunc :: MonadIO m => FlowBoxSortFunc -> m (GClosure C_FlowBoxSortFunc)

Wrap the callback into a GClosure.

mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc)

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

noFlowBoxSortFunc :: Maybe FlowBoxSortFunc

A convenience synonym for Nothing :: Maybe FlowBoxSortFunc.

noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures

A convenience synonym for Nothing :: Maybe FlowBoxSortFunc_WithClosures.

wrap_FlowBoxSortFunc :: Maybe (Ptr (FunPtr C_FlowBoxSortFunc)) -> FlowBoxSortFunc_WithClosures -> C_FlowBoxSortFunc

Wrap a FlowBoxSortFunc into a C_FlowBoxSortFunc.

FontFilterFunc

type C_FontFilterFunc = Ptr FontFamily -> Ptr FontFace -> Ptr () -> IO CInt

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

type FontFilterFunc

Arguments

 = FontFamily

family: a FontFamily

-> FontFace

face: a FontFace belonging to family

-> IO Bool

Returns: True if the font should be displayed

The type of function that is used for deciding what fonts get shown in a FontChooser. See fontChooserSetFilterFunc.

type FontFilterFunc_WithClosures

Arguments

 = FontFamily

family: a FontFamily

-> FontFace

face: a FontFace belonging to family

-> Ptr ()

data: user data passed to fontChooserSetFilterFunc

-> IO Bool

Returns: True if the font should be displayed

The type of function that is used for deciding what fonts get shown in a FontChooser. See fontChooserSetFilterFunc.

drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_FontFilterFunc

Arguments

:: (HasCallStack, MonadIO m, IsFontFamily a, IsFontFace b)

=> FunPtr C_FontFilterFunc

-> a

family: a FontFamily

-> b

face: a FontFace belonging to family

-> Ptr ()

data: user data passed to fontChooserSetFilterFunc

-> m Bool

Returns: True if the font should be displayed

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

genClosure_FontFilterFunc :: MonadIO m => FontFilterFunc -> m (GClosure C_FontFilterFunc)

Wrap the callback into a GClosure.

mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc)

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

noFontFilterFunc :: Maybe FontFilterFunc

A convenience synonym for Nothing :: Maybe FontFilterFunc.

noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe FontFilterFunc_WithClosures.

wrap_FontFilterFunc :: Maybe (Ptr (FunPtr C_FontFilterFunc)) -> FontFilterFunc_WithClosures -> C_FontFilterFunc

Wrap a FontFilterFunc into a C_FontFilterFunc.

IconViewForeachFunc

type C_IconViewForeachFunc = Ptr IconView -> Ptr TreePath -> Ptr () -> IO ()

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

type IconViewForeachFunc

Arguments

 = IconView

iconView: a IconView

-> TreePath

path: The TreePath of a selected row

-> IO ()

A function used by iconViewSelectedForeach to map all selected rows. It will be called on every selected row in the view.

type IconViewForeachFunc_WithClosures

Arguments

 = IconView

iconView: a IconView

-> TreePath

path: The TreePath of a selected row

-> Ptr ()

data: user data

-> IO ()

A function used by iconViewSelectedForeach to map all selected rows. It will be called on every selected row in the view.

drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_IconViewForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsIconView a)

=> FunPtr C_IconViewForeachFunc

-> a

iconView: a IconView

-> TreePath

path: The TreePath of a selected row

-> Ptr ()

data: user data

-> m ()

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

genClosure_IconViewForeachFunc :: MonadIO m => IconViewForeachFunc -> m (GClosure C_IconViewForeachFunc)

Wrap the callback into a GClosure.

mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc)

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

noIconViewForeachFunc :: Maybe IconViewForeachFunc

A convenience synonym for Nothing :: Maybe IconViewForeachFunc.

noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe IconViewForeachFunc_WithClosures.

wrap_IconViewForeachFunc :: Maybe (Ptr (FunPtr C_IconViewForeachFunc)) -> IconViewForeachFunc_WithClosures -> C_IconViewForeachFunc

Wrap a IconViewForeachFunc into a C_IconViewForeachFunc.

KeySnoopFunc

type C_KeySnoopFunc = Ptr Widget -> Ptr EventKey -> Ptr () -> IO Int32

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

type KeySnoopFunc

Arguments

 = Widget

grabWidget: the widget to which the event will be delivered

-> EventKey

event: the key event

-> IO Int32

Returns: True to stop further processing of event, False to continue.

Key snooper functions are called before normal event delivery. They can be used to implement custom key event handling.

type KeySnoopFunc_WithClosures

Arguments

 = Widget

grabWidget: the widget to which the event will be delivered

-> EventKey

event: the key event

-> Ptr ()

funcData: data supplied to gtk_key_snooper_install()

-> IO Int32

Returns: True to stop further processing of event, False to continue.

Key snooper functions are called before normal event delivery. They can be used to implement custom key event handling.

drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_KeySnoopFunc

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_KeySnoopFunc

-> a

grabWidget: the widget to which the event will be delivered

-> EventKey

event: the key event

-> Ptr ()

funcData: data supplied to gtk_key_snooper_install()

-> m Int32

Returns: True to stop further processing of event, False to continue.

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

genClosure_KeySnoopFunc :: MonadIO m => KeySnoopFunc -> m (GClosure C_KeySnoopFunc)

Wrap the callback into a GClosure.

mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc)

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

noKeySnoopFunc :: Maybe KeySnoopFunc

A convenience synonym for Nothing :: Maybe KeySnoopFunc.

noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures

A convenience synonym for Nothing :: Maybe KeySnoopFunc_WithClosures.

wrap_KeySnoopFunc :: Maybe (Ptr (FunPtr C_KeySnoopFunc)) -> KeySnoopFunc_WithClosures -> C_KeySnoopFunc

Wrap a KeySnoopFunc into a C_KeySnoopFunc.

ListBoxCreateWidgetFunc

type C_ListBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO (Ptr Widget)

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

type ListBoxCreateWidgetFunc

Arguments

 = Object

item: the item from the model for which to create a widget for

-> IO Widget

Returns: a Widget that represents item

Called for list boxes that are bound to a ListModel with listBoxBindModel for each item that gets added to the model.

Versions of GTK+ prior to 3.18 called widgetShowAll on the rows created by the GtkListBoxCreateWidgetFunc, but this forced all widgets inside the row to be shown, and is no longer the case. Applications should be updated to show the desired row widgets.

Since: 3.16

type ListBoxCreateWidgetFunc_WithClosures

Arguments

 = Object

item: the item from the model for which to create a widget for

-> Ptr ()

userData: user data

-> IO Widget

Returns: a Widget that represents item

Called for list boxes that are bound to a ListModel with listBoxBindModel for each item that gets added to the model.

Versions of GTK+ prior to 3.18 called widgetShowAll on the rows created by the GtkListBoxCreateWidgetFunc, but this forced all widgets inside the row to be shown, and is no longer the case. Applications should be updated to show the desired row widgets.

Since: 3.16

drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxCreateWidgetFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ListBoxCreateWidgetFunc

-> a

item: the item from the model for which to create a widget for

-> Ptr ()

userData: user data

-> m Widget

Returns: a Widget that represents item

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

genClosure_ListBoxCreateWidgetFunc :: MonadIO m => ListBoxCreateWidgetFunc -> m (GClosure C_ListBoxCreateWidgetFunc)

Wrap the callback into a GClosure.

mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc)

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

noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc

A convenience synonym for Nothing :: Maybe ListBoxCreateWidgetFunc.

noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures

A convenience synonym for Nothing :: Maybe ListBoxCreateWidgetFunc_WithClosures.

wrap_ListBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_ListBoxCreateWidgetFunc)) -> ListBoxCreateWidgetFunc_WithClosures -> C_ListBoxCreateWidgetFunc

Wrap a ListBoxCreateWidgetFunc into a C_ListBoxCreateWidgetFunc.

ListBoxFilterFunc

type C_ListBoxFilterFunc = Ptr ListBoxRow -> Ptr () -> IO CInt

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

type ListBoxFilterFunc

Arguments

 = ListBoxRow

row: the row that may be filtered

-> IO Bool

Returns: True if the row should be visible, False otherwise

Will be called whenever the row changes or is added and lets you control if the row should be visible or not.

Since: 3.10

type ListBoxFilterFunc_WithClosures

Arguments

 = ListBoxRow

row: the row that may be filtered

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the row should be visible, False otherwise

Will be called whenever the row changes or is added and lets you control if the row should be visible or not.

Since: 3.10

drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxFilterFunc

Arguments

:: (HasCallStack, MonadIO m, IsListBoxRow a)

=> FunPtr C_ListBoxFilterFunc

-> a

row: the row that may be filtered

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the row should be visible, False otherwise

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

genClosure_ListBoxFilterFunc :: MonadIO m => ListBoxFilterFunc -> m (GClosure C_ListBoxFilterFunc)

Wrap the callback into a GClosure.

mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc)

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

noListBoxFilterFunc :: Maybe ListBoxFilterFunc

A convenience synonym for Nothing :: Maybe ListBoxFilterFunc.

noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe ListBoxFilterFunc_WithClosures.

wrap_ListBoxFilterFunc :: Maybe (Ptr (FunPtr C_ListBoxFilterFunc)) -> ListBoxFilterFunc_WithClosures -> C_ListBoxFilterFunc

Wrap a ListBoxFilterFunc into a C_ListBoxFilterFunc.

ListBoxForeachFunc

type C_ListBoxForeachFunc = Ptr ListBox -> Ptr ListBoxRow -> Ptr () -> IO ()

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

type ListBoxForeachFunc

Arguments

 = ListBox

box: a ListBox

-> ListBoxRow

row: a ListBoxRow

-> IO ()

A function used by listBoxSelectedForeach. It will be called on every selected child of the box.

Since: 3.14

type ListBoxForeachFunc_WithClosures

Arguments

 = ListBox

box: a ListBox

-> ListBoxRow

row: a ListBoxRow

-> Ptr ()

userData: user data

-> IO ()

A function used by listBoxSelectedForeach. It will be called on every selected child of the box.

Since: 3.14

drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b)

=> FunPtr C_ListBoxForeachFunc

-> a

box: a ListBox

-> b

row: a ListBoxRow

-> Ptr ()

userData: user data

-> m ()

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

genClosure_ListBoxForeachFunc :: MonadIO m => ListBoxForeachFunc -> m (GClosure C_ListBoxForeachFunc)

Wrap the callback into a GClosure.

mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc)

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

noListBoxForeachFunc :: Maybe ListBoxForeachFunc

A convenience synonym for Nothing :: Maybe ListBoxForeachFunc.

noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe ListBoxForeachFunc_WithClosures.

wrap_ListBoxForeachFunc :: Maybe (Ptr (FunPtr C_ListBoxForeachFunc)) -> ListBoxForeachFunc_WithClosures -> C_ListBoxForeachFunc

Wrap a ListBoxForeachFunc into a C_ListBoxForeachFunc.

ListBoxSortFunc

type C_ListBoxSortFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO Int32

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

type ListBoxSortFunc

Arguments

 = ListBoxRow

row1: the first row

-> ListBoxRow

row2: the second row

-> IO Int32

Returns: < 0 if row1 should be before row2, 0 if they are equal and > 0 otherwise

Compare two rows to determine which should be first.

Since: 3.10

type ListBoxSortFunc_WithClosures

Arguments

 = ListBoxRow

row1: the first row

-> ListBoxRow

row2: the second row

-> Ptr ()

userData: user data

-> IO Int32

Returns: < 0 if row1 should be before row2, 0 if they are equal and > 0 otherwise

Compare two rows to determine which should be first.

Since: 3.10

drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxSortFunc

Arguments

:: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b)

=> FunPtr C_ListBoxSortFunc

-> a

row1: the first row

-> b

row2: the second row

-> Ptr ()

userData: user data

-> m Int32

Returns: < 0 if row1 should be before row2, 0 if they are equal and > 0 otherwise

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

genClosure_ListBoxSortFunc :: MonadIO m => ListBoxSortFunc -> m (GClosure C_ListBoxSortFunc)

Wrap the callback into a GClosure.

mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc)

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

noListBoxSortFunc :: Maybe ListBoxSortFunc

A convenience synonym for Nothing :: Maybe ListBoxSortFunc.

noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures

A convenience synonym for Nothing :: Maybe ListBoxSortFunc_WithClosures.

wrap_ListBoxSortFunc :: Maybe (Ptr (FunPtr C_ListBoxSortFunc)) -> ListBoxSortFunc_WithClosures -> C_ListBoxSortFunc

Wrap a ListBoxSortFunc into a C_ListBoxSortFunc.

ListBoxUpdateHeaderFunc

type C_ListBoxUpdateHeaderFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO ()

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

type ListBoxUpdateHeaderFunc

Arguments

 = ListBoxRow

row: the row to update

-> Maybe ListBoxRow

before: the row before row, or Nothing if it is first

-> IO ()

Whenever row changes or which row is before row changes this is called, which lets you update the header on row. You may remove or set a new one via listBoxRowSetHeader or just change the state of the current header widget.

Since: 3.10

type ListBoxUpdateHeaderFunc_WithClosures

Arguments

 = ListBoxRow

row: the row to update

-> Maybe ListBoxRow

before: the row before row, or Nothing if it is first

-> Ptr ()

userData: user data

-> IO ()

Whenever row changes or which row is before row changes this is called, which lets you update the header on row. You may remove or set a new one via listBoxRowSetHeader or just change the state of the current header widget.

Since: 3.10

drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxUpdateHeaderFunc

Arguments

:: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b)

=> FunPtr C_ListBoxUpdateHeaderFunc

-> a

row: the row to update

-> Maybe b

before: the row before row, or Nothing if it is first

-> Ptr ()

userData: user data

-> m ()

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

genClosure_ListBoxUpdateHeaderFunc :: MonadIO m => ListBoxUpdateHeaderFunc -> m (GClosure C_ListBoxUpdateHeaderFunc)

Wrap the callback into a GClosure.

mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc)

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

noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc

A convenience synonym for Nothing :: Maybe ListBoxUpdateHeaderFunc.

noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures

A convenience synonym for Nothing :: Maybe ListBoxUpdateHeaderFunc_WithClosures.

wrap_ListBoxUpdateHeaderFunc :: Maybe (Ptr (FunPtr C_ListBoxUpdateHeaderFunc)) -> ListBoxUpdateHeaderFunc_WithClosures -> C_ListBoxUpdateHeaderFunc

Wrap a ListBoxUpdateHeaderFunc into a C_ListBoxUpdateHeaderFunc.

MenuDetachFunc

type C_MenuDetachFunc = Ptr Widget -> Ptr Menu -> IO ()

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

type MenuDetachFunc

Arguments

 = Widget

attachWidget: the Widget that the menu is being detached from.

-> Menu

menu: the Menu being detached.

-> IO ()

A user function supplied when calling menuAttachToWidget which will be called when the menu is later detached from the widget.

dynamic_MenuDetachFunc

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsMenu b)

=> FunPtr C_MenuDetachFunc

-> a

attachWidget: the Widget that the menu is being detached from.

-> b

menu: the Menu being detached.

-> m ()

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

genClosure_MenuDetachFunc :: MonadIO m => MenuDetachFunc -> m (GClosure C_MenuDetachFunc)

Wrap the callback into a GClosure.

mk_MenuDetachFunc :: C_MenuDetachFunc -> IO (FunPtr C_MenuDetachFunc)

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

noMenuDetachFunc :: Maybe MenuDetachFunc

A convenience synonym for Nothing :: Maybe MenuDetachFunc.

wrap_MenuDetachFunc :: Maybe (Ptr (FunPtr C_MenuDetachFunc)) -> MenuDetachFunc -> C_MenuDetachFunc

Wrap a MenuDetachFunc into a C_MenuDetachFunc.

MenuPositionFunc

type C_MenuPositionFunc = Ptr Menu -> Ptr Int32 -> Ptr Int32 -> Ptr CInt -> Ptr () -> IO ()

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

type MenuPositionFunc

Arguments

 = Menu

menu: a Menu.

-> Int32

x: address of the gint representing the horizontal position where the menu shall be drawn.

-> Int32

y: address of the gint representing the vertical position where the menu shall be drawn. This is an output parameter.

-> IO (Int32, Int32, Bool)

A user function supplied when calling menuPopup which controls the positioning of the menu when it is displayed. The function sets the x and y parameters to the coordinates where the menu is to be drawn. To make the menu appear on a different monitor than the mouse pointer, menuSetMonitor must be called.

type MenuPositionFunc_WithClosures

Arguments

 = Menu

menu: a Menu.

-> Int32

x: address of the gint representing the horizontal position where the menu shall be drawn.

-> Int32

y: address of the gint representing the vertical position where the menu shall be drawn. This is an output parameter.

-> Ptr ()

userData: the data supplied by the user in the menuPopup data parameter.

-> IO (Int32, Int32, Bool)

A user function supplied when calling menuPopup which controls the positioning of the menu when it is displayed. The function sets the x and y parameters to the coordinates where the menu is to be drawn. To make the menu appear on a different monitor than the mouse pointer, menuSetMonitor must be called.

drop_closures_MenuPositionFunc :: MenuPositionFunc -> MenuPositionFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MenuPositionFunc

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)

=> FunPtr C_MenuPositionFunc

-> a

menu: a Menu.

-> Int32

x: address of the gint representing the horizontal position where the menu shall be drawn.

-> Int32

y: address of the gint representing the vertical position where the menu shall be drawn. This is an output parameter.

-> Ptr ()

userData: the data supplied by the user in the menuPopup data parameter.

-> m (Int32, Int32, Bool)

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

genClosure_MenuPositionFunc :: MonadIO m => MenuPositionFunc -> m (GClosure C_MenuPositionFunc)

Wrap the callback into a GClosure.

mk_MenuPositionFunc :: C_MenuPositionFunc -> IO (FunPtr C_MenuPositionFunc)

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

noMenuPositionFunc :: Maybe MenuPositionFunc

A convenience synonym for Nothing :: Maybe MenuPositionFunc.

noMenuPositionFunc_WithClosures :: Maybe MenuPositionFunc_WithClosures

A convenience synonym for Nothing :: Maybe MenuPositionFunc_WithClosures.

wrap_MenuPositionFunc :: Maybe (Ptr (FunPtr C_MenuPositionFunc)) -> MenuPositionFunc_WithClosures -> C_MenuPositionFunc

Wrap a MenuPositionFunc into a C_MenuPositionFunc.

ModuleDisplayInitFunc

type C_ModuleDisplayInitFunc = Ptr Display -> IO ()

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

type ModuleDisplayInitFunc

Arguments

 = Display

display: an open Display

-> IO ()

A multihead-aware GTK+ module may have a gtk_module_display_init() function with this prototype. GTK+ calls this function for each opened display.

Since: 2.2

dynamic_ModuleDisplayInitFunc

Arguments

:: (HasCallStack, MonadIO m, IsDisplay a)

=> FunPtr C_ModuleDisplayInitFunc

-> a

display: an open Display

-> m ()

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

genClosure_ModuleDisplayInitFunc :: MonadIO m => ModuleDisplayInitFunc -> m (GClosure C_ModuleDisplayInitFunc)

Wrap the callback into a GClosure.

mk_ModuleDisplayInitFunc :: C_ModuleDisplayInitFunc -> IO (FunPtr C_ModuleDisplayInitFunc)

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

noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc

A convenience synonym for Nothing :: Maybe ModuleDisplayInitFunc.

wrap_ModuleDisplayInitFunc :: Maybe (Ptr (FunPtr C_ModuleDisplayInitFunc)) -> ModuleDisplayInitFunc -> C_ModuleDisplayInitFunc

Wrap a ModuleDisplayInitFunc into a C_ModuleDisplayInitFunc.

ModuleInitFunc

type C_ModuleInitFunc = Int32 -> Ptr CString -> IO ()

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

type ModuleInitFunc

Arguments

 = Maybe [Text]

argv: GTK+ always passes Nothing for this argument

-> IO ()

Each GTK+ module must have a function gtk_module_init() with this prototype. This function is called after loading the module.

dynamic_ModuleInitFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ModuleInitFunc

-> Maybe [Text]

argv: GTK+ always passes Nothing for this argument

-> m ()

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

genClosure_ModuleInitFunc :: MonadIO m => ModuleInitFunc -> m (GClosure C_ModuleInitFunc)

Wrap the callback into a GClosure.

mk_ModuleInitFunc :: C_ModuleInitFunc -> IO (FunPtr C_ModuleInitFunc)

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

noModuleInitFunc :: Maybe ModuleInitFunc

A convenience synonym for Nothing :: Maybe ModuleInitFunc.

wrap_ModuleInitFunc :: Maybe (Ptr (FunPtr C_ModuleInitFunc)) -> ModuleInitFunc -> C_ModuleInitFunc

Wrap a ModuleInitFunc into a C_ModuleInitFunc.

PageSetupDoneFunc

type C_PageSetupDoneFunc = Ptr PageSetup -> Ptr () -> IO ()

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

type PageSetupDoneFunc

Arguments

 = PageSetup

pageSetup: the PageSetup that has been

-> IO ()

The type of function that is passed to printRunPageSetupDialogAsync.

This function will be called when the page setup dialog is dismissed, and also serves as destroy notify for data.

type PageSetupDoneFunc_WithClosures

Arguments

 = PageSetup

pageSetup: the PageSetup that has been

-> Ptr ()

data: user data that has been passed to printRunPageSetupDialogAsync

-> IO ()

The type of function that is passed to printRunPageSetupDialogAsync.

This function will be called when the page setup dialog is dismissed, and also serves as destroy notify for data.

drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PageSetupDoneFunc

Arguments

:: (HasCallStack, MonadIO m, IsPageSetup a)

=> FunPtr C_PageSetupDoneFunc

-> a

pageSetup: the PageSetup that has been

-> Ptr ()

data: user data that has been passed to printRunPageSetupDialogAsync

-> m ()

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

genClosure_PageSetupDoneFunc :: MonadIO m => PageSetupDoneFunc -> m (GClosure C_PageSetupDoneFunc)

Wrap the callback into a GClosure.

mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc)

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

noPageSetupDoneFunc :: Maybe PageSetupDoneFunc

A convenience synonym for Nothing :: Maybe PageSetupDoneFunc.

noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures

A convenience synonym for Nothing :: Maybe PageSetupDoneFunc_WithClosures.

wrap_PageSetupDoneFunc :: Maybe (Ptr (FunPtr C_PageSetupDoneFunc)) -> PageSetupDoneFunc_WithClosures -> C_PageSetupDoneFunc

Wrap a PageSetupDoneFunc into a C_PageSetupDoneFunc.

PrintSettingsFunc

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

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

type PrintSettingsFunc = Text -> Text -> IO ()

No description available in the introspection data.

type PrintSettingsFunc_WithClosures = Text -> Text -> Ptr () -> IO ()

No description available in the introspection data.

drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PrintSettingsFunc :: (HasCallStack, MonadIO m) => FunPtr C_PrintSettingsFunc -> Text -> Text -> Ptr () -> m ()

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

genClosure_PrintSettingsFunc :: MonadIO m => PrintSettingsFunc -> m (GClosure C_PrintSettingsFunc)

Wrap the callback into a GClosure.

mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc)

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

noPrintSettingsFunc :: Maybe PrintSettingsFunc

A convenience synonym for Nothing :: Maybe PrintSettingsFunc.

noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures

A convenience synonym for Nothing :: Maybe PrintSettingsFunc_WithClosures.

wrap_PrintSettingsFunc :: Maybe (Ptr (FunPtr C_PrintSettingsFunc)) -> PrintSettingsFunc_WithClosures -> C_PrintSettingsFunc

Wrap a PrintSettingsFunc into a C_PrintSettingsFunc.

RcPropertyParser

type C_RcPropertyParser = Ptr GParamSpec -> Ptr String -> Ptr GValue -> IO CInt

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

type RcPropertyParser = GParamSpec -> String -> GValue -> IO Bool

No description available in the introspection data.

dynamic_RcPropertyParser :: (HasCallStack, MonadIO m) => FunPtr C_RcPropertyParser -> GParamSpec -> String -> GValue -> m Bool

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

genClosure_RcPropertyParser :: MonadIO m => RcPropertyParser -> m (GClosure C_RcPropertyParser)

Wrap the callback into a GClosure.

mk_RcPropertyParser :: C_RcPropertyParser -> IO (FunPtr C_RcPropertyParser)

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

noRcPropertyParser :: Maybe RcPropertyParser

A convenience synonym for Nothing :: Maybe RcPropertyParser.

wrap_RcPropertyParser :: Maybe (Ptr (FunPtr C_RcPropertyParser)) -> RcPropertyParser -> C_RcPropertyParser

Wrap a RcPropertyParser into a C_RcPropertyParser.

RecentFilterFunc

type C_RecentFilterFunc = Ptr RecentFilterInfo -> Ptr () -> IO CInt

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

type RecentFilterFunc

Arguments

 = RecentFilterInfo

filterInfo: a RecentFilterInfo that is filled according to the needed flags passed to recentFilterAddCustom

-> IO Bool

Returns: True if the file should be displayed

The type of function that is used with custom filters, see recentFilterAddCustom.

type RecentFilterFunc_WithClosures

Arguments

 = RecentFilterInfo

filterInfo: a RecentFilterInfo that is filled according to the needed flags passed to recentFilterAddCustom

-> Ptr ()

userData: user data passed to recentFilterAddCustom

-> IO Bool

Returns: True if the file should be displayed

The type of function that is used with custom filters, see recentFilterAddCustom.

drop_closures_RecentFilterFunc :: RecentFilterFunc -> RecentFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_RecentFilterFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_RecentFilterFunc

-> RecentFilterInfo

filterInfo: a RecentFilterInfo that is filled according to the needed flags passed to recentFilterAddCustom

-> Ptr ()

userData: user data passed to recentFilterAddCustom

-> m Bool

Returns: True if the file should be displayed

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

genClosure_RecentFilterFunc :: MonadIO m => RecentFilterFunc -> m (GClosure C_RecentFilterFunc)

Wrap the callback into a GClosure.

mk_RecentFilterFunc :: C_RecentFilterFunc -> IO (FunPtr C_RecentFilterFunc)

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

noRecentFilterFunc :: Maybe RecentFilterFunc

A convenience synonym for Nothing :: Maybe RecentFilterFunc.

noRecentFilterFunc_WithClosures :: Maybe RecentFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe RecentFilterFunc_WithClosures.

wrap_RecentFilterFunc :: Maybe (Ptr (FunPtr C_RecentFilterFunc)) -> RecentFilterFunc_WithClosures -> C_RecentFilterFunc

Wrap a RecentFilterFunc into a C_RecentFilterFunc.

RecentSortFunc

type C_RecentSortFunc = Ptr RecentInfo -> Ptr RecentInfo -> Ptr () -> IO Int32

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

type RecentSortFunc = RecentInfo -> RecentInfo -> IO Int32

No description available in the introspection data.

type RecentSortFunc_WithClosures = RecentInfo -> RecentInfo -> Ptr () -> IO Int32

No description available in the introspection data.

drop_closures_RecentSortFunc :: RecentSortFunc -> RecentSortFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_RecentSortFunc :: (HasCallStack, MonadIO m) => FunPtr C_RecentSortFunc -> RecentInfo -> RecentInfo -> Ptr () -> m Int32

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

genClosure_RecentSortFunc :: MonadIO m => RecentSortFunc -> m (GClosure C_RecentSortFunc)

Wrap the callback into a GClosure.

mk_RecentSortFunc :: C_RecentSortFunc -> IO (FunPtr C_RecentSortFunc)

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

noRecentSortFunc :: Maybe RecentSortFunc

A convenience synonym for Nothing :: Maybe RecentSortFunc.

noRecentSortFunc_WithClosures :: Maybe RecentSortFunc_WithClosures

A convenience synonym for Nothing :: Maybe RecentSortFunc_WithClosures.

wrap_RecentSortFunc :: Maybe (Ptr (FunPtr C_RecentSortFunc)) -> RecentSortFunc_WithClosures -> C_RecentSortFunc

Wrap a RecentSortFunc into a C_RecentSortFunc.

StylePropertyParser

type C_StylePropertyParser = CString -> Ptr GValue -> Ptr (Ptr GError) -> IO CInt

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

type StylePropertyParser

Arguments

 = Text

-> GValue

-> IO ()

(Can throw GError)

No description available in the introspection data.

dynamic_StylePropertyParser

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_StylePropertyParser

-> Text

-> GValue

-> m ()

(Can throw GError)

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

mk_StylePropertyParser :: C_StylePropertyParser -> IO (FunPtr C_StylePropertyParser)

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

noStylePropertyParser :: Maybe StylePropertyParser

A convenience synonym for Nothing :: Maybe StylePropertyParser.

TextBufferDeserializeFunc

type C_TextBufferDeserializeFunc = Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr Word8 -> Word64 -> CInt -> Ptr () -> Ptr (Ptr GError) -> IO CInt

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

type TextBufferDeserializeFunc

Arguments

 = TextBuffer

registerBuffer: the TextBuffer the format is registered with

-> TextBuffer

contentBuffer: the TextBuffer to deserialize into

-> TextIter

iter: insertion point for the deserialized text

-> ByteString

data: data to deserialize

-> Bool

createTags: True if deserializing may create tags

-> IO ()

Returns: True on success, False otherwise (Can throw GError)

A function that is called to deserialize rich text that has been serialized with textBufferSerialize, and insert it at iter.

type TextBufferDeserializeFunc_WithClosures

Arguments

 = TextBuffer

registerBuffer: the TextBuffer the format is registered with

-> TextBuffer

contentBuffer: the TextBuffer to deserialize into

-> TextIter

iter: insertion point for the deserialized text

-> ByteString

data: data to deserialize

-> Bool

createTags: True if deserializing may create tags

-> Ptr ()

userData: user data that was specified when registering the format

-> IO ()

Returns: True on success, False otherwise (Can throw GError)

A function that is called to deserialize rich text that has been serialized with textBufferSerialize, and insert it at iter.

drop_closures_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> TextBufferDeserializeFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TextBufferDeserializeFunc

Arguments

:: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b)

=> FunPtr C_TextBufferDeserializeFunc

-> a

registerBuffer: the TextBuffer the format is registered with

-> b

contentBuffer: the TextBuffer to deserialize into

-> TextIter

iter: insertion point for the deserialized text

-> ByteString

data: data to deserialize

-> Bool

createTags: True if deserializing may create tags

-> Ptr ()

userData: user data that was specified when registering the format

-> m ()

(Can throw GError)

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

mk_TextBufferDeserializeFunc :: C_TextBufferDeserializeFunc -> IO (FunPtr C_TextBufferDeserializeFunc)

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

noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc

A convenience synonym for Nothing :: Maybe TextBufferDeserializeFunc.

noTextBufferDeserializeFunc_WithClosures :: Maybe TextBufferDeserializeFunc_WithClosures

A convenience synonym for Nothing :: Maybe TextBufferDeserializeFunc_WithClosures.

TextBufferSerializeFunc

type C_TextBufferSerializeFunc = Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr TextIter -> Ptr Word64 -> Ptr () -> IO (Ptr Word8)

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

type TextBufferSerializeFunc

Arguments

 = TextBuffer

registerBuffer: the TextBuffer for which the format is registered

-> TextBuffer

contentBuffer: the TextBuffer to serialize

-> TextIter

start: start of the block of text to serialize

-> TextIter

end: end of the block of text to serialize

-> IO (Maybe ByteString)

Returns: a newly-allocated array of guint8 which contains the serialized data, or Nothing if an error occurred

A function that is called to serialize the content of a text buffer. It must return the serialized form of the content.

type TextBufferSerializeFunc_WithClosures

Arguments

 = TextBuffer

registerBuffer: the TextBuffer for which the format is registered

-> TextBuffer

contentBuffer: the TextBuffer to serialize

-> TextIter

start: start of the block of text to serialize

-> TextIter

end: end of the block of text to serialize

-> Ptr ()

userData: user data that was specified when registering the format

-> IO (Maybe ByteString)

Returns: a newly-allocated array of guint8 which contains the serialized data, or Nothing if an error occurred

A function that is called to serialize the content of a text buffer. It must return the serialized form of the content.

drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TextBufferSerializeFunc

Arguments

:: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b)

=> FunPtr C_TextBufferSerializeFunc

-> a

registerBuffer: the TextBuffer for which the format is registered

-> b

contentBuffer: the TextBuffer to serialize

-> TextIter

start: start of the block of text to serialize

-> TextIter

end: end of the block of text to serialize

-> Ptr ()

userData: user data that was specified when registering the format

-> m (Maybe ByteString)

Returns: a newly-allocated array of guint8 which contains the serialized data, or Nothing if an error occurred

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

genClosure_TextBufferSerializeFunc :: MonadIO m => TextBufferSerializeFunc -> m (GClosure C_TextBufferSerializeFunc)

Wrap the callback into a GClosure.

mk_TextBufferSerializeFunc :: C_TextBufferSerializeFunc -> IO (FunPtr C_TextBufferSerializeFunc)

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

noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc

A convenience synonym for Nothing :: Maybe TextBufferSerializeFunc.

noTextBufferSerializeFunc_WithClosures :: Maybe TextBufferSerializeFunc_WithClosures

A convenience synonym for Nothing :: Maybe TextBufferSerializeFunc_WithClosures.

wrap_TextBufferSerializeFunc :: Maybe (Ptr (FunPtr C_TextBufferSerializeFunc)) -> TextBufferSerializeFunc_WithClosures -> C_TextBufferSerializeFunc

Wrap a TextBufferSerializeFunc into a C_TextBufferSerializeFunc.

TextCharPredicate

type C_TextCharPredicate = CInt -> Ptr () -> IO CInt

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

type TextCharPredicate = Char -> IO Bool

No description available in the introspection data.

type TextCharPredicate_WithClosures = Char -> Ptr () -> IO Bool

No description available in the introspection data.

drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TextCharPredicate :: (HasCallStack, MonadIO m) => FunPtr C_TextCharPredicate -> Char -> Ptr () -> m Bool

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

genClosure_TextCharPredicate :: MonadIO m => TextCharPredicate -> m (GClosure C_TextCharPredicate)

Wrap the callback into a GClosure.

mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate)

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

noTextCharPredicate :: Maybe TextCharPredicate

A convenience synonym for Nothing :: Maybe TextCharPredicate.

noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures

A convenience synonym for Nothing :: Maybe TextCharPredicate_WithClosures.

wrap_TextCharPredicate :: Maybe (Ptr (FunPtr C_TextCharPredicate)) -> TextCharPredicate_WithClosures -> C_TextCharPredicate

Wrap a TextCharPredicate into a C_TextCharPredicate.

TextTagTableForeach

type C_TextTagTableForeach = Ptr TextTag -> Ptr () -> IO ()

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

type TextTagTableForeach

Arguments

 = TextTag

tag: the TextTag

-> IO ()

No description available in the introspection data.

type TextTagTableForeach_WithClosures

Arguments

 = TextTag

tag: the TextTag

-> Ptr ()

data: data passed to textTagTableForeach

-> IO ()

No description available in the introspection data.

drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TextTagTableForeach

Arguments

:: (HasCallStack, MonadIO m, IsTextTag a)

=> FunPtr C_TextTagTableForeach

-> a

tag: the TextTag

-> Ptr ()

data: data passed to textTagTableForeach

-> m ()

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

genClosure_TextTagTableForeach :: MonadIO m => TextTagTableForeach -> m (GClosure C_TextTagTableForeach)

Wrap the callback into a GClosure.

mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)

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

noTextTagTableForeach :: Maybe TextTagTableForeach

A convenience synonym for Nothing :: Maybe TextTagTableForeach.

noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures

A convenience synonym for Nothing :: Maybe TextTagTableForeach_WithClosures.

wrap_TextTagTableForeach :: Maybe (Ptr (FunPtr C_TextTagTableForeach)) -> TextTagTableForeach_WithClosures -> C_TextTagTableForeach

Wrap a TextTagTableForeach into a C_TextTagTableForeach.

TickCallback

type C_TickCallback = Ptr Widget -> Ptr FrameClock -> Ptr () -> IO CInt

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

type TickCallback

Arguments

 = Widget

widget: the widget

-> FrameClock

frameClock: the frame clock for the widget (same as calling widgetGetFrameClock)

-> IO Bool

Returns: SOURCE_CONTINUE if the tick callback should continue to be called, SOURCE_REMOVE if the tick callback should be removed.

Callback type for adding a function to update animations. See widgetAddTickCallback.

Since: 3.8

type TickCallback_WithClosures

Arguments

 = Widget

widget: the widget

-> FrameClock

frameClock: the frame clock for the widget (same as calling widgetGetFrameClock)

-> Ptr ()

userData: user data passed to widgetAddTickCallback.

-> IO Bool

Returns: SOURCE_CONTINUE if the tick callback should continue to be called, SOURCE_REMOVE if the tick callback should be removed.

Callback type for adding a function to update animations. See widgetAddTickCallback.

Since: 3.8

drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TickCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsFrameClock b)

=> FunPtr C_TickCallback

-> a

widget: the widget

-> b

frameClock: the frame clock for the widget (same as calling widgetGetFrameClock)

-> Ptr ()

userData: user data passed to widgetAddTickCallback.

-> m Bool

Returns: SOURCE_CONTINUE if the tick callback should continue to be called, SOURCE_REMOVE if the tick callback should be removed.

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

genClosure_TickCallback :: MonadIO m => TickCallback -> m (GClosure C_TickCallback)

Wrap the callback into a GClosure.

mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback)

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

noTickCallback :: Maybe TickCallback

A convenience synonym for Nothing :: Maybe TickCallback.

noTickCallback_WithClosures :: Maybe TickCallback_WithClosures

A convenience synonym for Nothing :: Maybe TickCallback_WithClosures.

wrap_TickCallback :: Maybe (Ptr (FunPtr C_TickCallback)) -> TickCallback_WithClosures -> C_TickCallback

Wrap a TickCallback into a C_TickCallback.

TranslateFunc

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

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

type TranslateFunc

Arguments

 = Text

path: The id of the message. In ActionGroup this will be a label or tooltip from a ActionEntry.

-> IO Text

Returns: the translated message

Deprecated: (Since version 3.10)

The function used to translate messages in e.g. IconFactory and ActionGroup.

type TranslateFunc_WithClosures

Arguments

 = Text

path: The id of the message. In ActionGroup this will be a label or tooltip from a ActionEntry.

-> Ptr ()

funcData: user data passed in when registering the function

-> IO Text

Returns: the translated message

The function used to translate messages in e.g. IconFactory and ActionGroup.

drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TranslateFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TranslateFunc

-> Text

path: The id of the message. In ActionGroup this will be a label or tooltip from a ActionEntry.

-> Ptr ()

funcData: user data passed in when registering the function

-> m Text

Returns: the translated message

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

genClosure_TranslateFunc :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc)

Wrap the callback into a GClosure.

mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc)

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

noTranslateFunc :: Maybe TranslateFunc

A convenience synonym for Nothing :: Maybe TranslateFunc.

noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures

A convenience synonym for Nothing :: Maybe TranslateFunc_WithClosures.

wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc_WithClosures -> C_TranslateFunc

Wrap a TranslateFunc into a C_TranslateFunc.

TreeCellDataFunc

type C_TreeCellDataFunc = Ptr TreeViewColumn -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

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

type TreeCellDataFunc

Arguments

 = TreeViewColumn

treeColumn: A TreeViewColumn

-> CellRenderer

cell: The CellRenderer that is being rendered by treeColumn

-> TreeModel

treeModel: The TreeModel being rendered

-> TreeIter

iter: A TreeIter of the current row rendered

-> IO ()

A function to set the properties of a cell instead of just using the straight mapping between the cell and the model. This is useful for customizing the cell renderer. For example, a function might get an integer from the treeModel, and render it to the “text” attribute of “cell” by converting it to its written equivalent. This is set by calling treeViewColumnSetCellDataFunc

type TreeCellDataFunc_WithClosures

Arguments

 = TreeViewColumn

treeColumn: A TreeViewColumn

-> CellRenderer

cell: The CellRenderer that is being rendered by treeColumn

-> TreeModel

treeModel: The TreeModel being rendered

-> TreeIter

iter: A TreeIter of the current row rendered

-> Ptr ()

data: user data

-> IO ()

A function to set the properties of a cell instead of just using the straight mapping between the cell and the model. This is useful for customizing the cell renderer. For example, a function might get an integer from the treeModel, and render it to the “text” attribute of “cell” by converting it to its written equivalent. This is set by calling treeViewColumnSetCellDataFunc

drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeCellDataFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b, IsTreeModel c)

=> FunPtr C_TreeCellDataFunc

-> a

treeColumn: A TreeViewColumn

-> b

cell: The CellRenderer that is being rendered by treeColumn

-> c

treeModel: The TreeModel being rendered

-> TreeIter

iter: A TreeIter of the current row rendered

-> Ptr ()

data: user data

-> m ()

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

genClosure_TreeCellDataFunc :: MonadIO m => TreeCellDataFunc -> m (GClosure C_TreeCellDataFunc)

Wrap the callback into a GClosure.

mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)

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

noTreeCellDataFunc :: Maybe TreeCellDataFunc

A convenience synonym for Nothing :: Maybe TreeCellDataFunc.

noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeCellDataFunc_WithClosures.

wrap_TreeCellDataFunc :: Maybe (Ptr (FunPtr C_TreeCellDataFunc)) -> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc

Wrap a TreeCellDataFunc into a C_TreeCellDataFunc.

TreeDestroyCountFunc

type C_TreeDestroyCountFunc = Ptr TreeView -> Ptr TreePath -> Int32 -> Ptr () -> IO ()

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

type TreeDestroyCountFunc = TreeView -> TreePath -> Int32 -> IO ()

No description available in the introspection data.

type TreeDestroyCountFunc_WithClosures = TreeView -> TreePath -> Int32 -> Ptr () -> IO ()

No description available in the introspection data.

drop_closures_TreeDestroyCountFunc :: TreeDestroyCountFunc -> TreeDestroyCountFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeDestroyCountFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeDestroyCountFunc -> a -> TreePath -> Int32 -> Ptr () -> m ()

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

genClosure_TreeDestroyCountFunc :: MonadIO m => TreeDestroyCountFunc -> m (GClosure C_TreeDestroyCountFunc)

Wrap the callback into a GClosure.

mk_TreeDestroyCountFunc :: C_TreeDestroyCountFunc -> IO (FunPtr C_TreeDestroyCountFunc)

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

noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc

A convenience synonym for Nothing :: Maybe TreeDestroyCountFunc.

noTreeDestroyCountFunc_WithClosures :: Maybe TreeDestroyCountFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeDestroyCountFunc_WithClosures.

wrap_TreeDestroyCountFunc :: Maybe (Ptr (FunPtr C_TreeDestroyCountFunc)) -> TreeDestroyCountFunc_WithClosures -> C_TreeDestroyCountFunc

Wrap a TreeDestroyCountFunc into a C_TreeDestroyCountFunc.

TreeIterCompareFunc

type C_TreeIterCompareFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr TreeIter -> Ptr () -> IO Int32

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

type TreeIterCompareFunc

Arguments

 = TreeModel

model: The TreeModel the comparison is within

-> TreeIter

a: A TreeIter in model

-> TreeIter

b: Another TreeIter in model

-> IO Int32

Returns: a negative integer, zero or a positive integer depending on whether a sorts before, with or after b

A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive integer if a sorts before b, a sorts with b, or a sorts after b respectively. If two iters compare as equal, their order in the sorted model is undefined. In order to ensure that the TreeSortable behaves as expected, the GtkTreeIterCompareFunc must define a partial order on the model, i.e. it must be reflexive, antisymmetric and transitive.

For example, if model is a product catalogue, then a compare function for the “price” column could be one which returns price_of(@a) - price_of(@b).

type TreeIterCompareFunc_WithClosures

Arguments

 = TreeModel

model: The TreeModel the comparison is within

-> TreeIter

a: A TreeIter in model

-> TreeIter

b: Another TreeIter in model

-> Ptr ()

userData: Data passed when the compare func is assigned e.g. by treeSortableSetSortFunc

-> IO Int32

Returns: a negative integer, zero or a positive integer depending on whether a sorts before, with or after b

A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive integer if a sorts before b, a sorts with b, or a sorts after b respectively. If two iters compare as equal, their order in the sorted model is undefined. In order to ensure that the TreeSortable behaves as expected, the GtkTreeIterCompareFunc must define a partial order on the model, i.e. it must be reflexive, antisymmetric and transitive.

For example, if model is a product catalogue, then a compare function for the “price” column could be one which returns price_of(@a) - price_of(@b).

drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeIterCompareFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)

=> FunPtr C_TreeIterCompareFunc

-> a

model: The TreeModel the comparison is within

-> TreeIter

a: A TreeIter in model

-> TreeIter

b: Another TreeIter in model

-> Ptr ()

userData: Data passed when the compare func is assigned e.g. by treeSortableSetSortFunc

-> m Int32

Returns: a negative integer, zero or a positive integer depending on whether a sorts before, with or after b

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

genClosure_TreeIterCompareFunc :: MonadIO m => TreeIterCompareFunc -> m (GClosure C_TreeIterCompareFunc)

Wrap the callback into a GClosure.

mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)

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

noTreeIterCompareFunc :: Maybe TreeIterCompareFunc

A convenience synonym for Nothing :: Maybe TreeIterCompareFunc.

noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeIterCompareFunc_WithClosures.

wrap_TreeIterCompareFunc :: Maybe (Ptr (FunPtr C_TreeIterCompareFunc)) -> TreeIterCompareFunc_WithClosures -> C_TreeIterCompareFunc

Wrap a TreeIterCompareFunc into a C_TreeIterCompareFunc.

TreeModelFilterModifyFunc

type C_TreeModelFilterModifyFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr GValue -> Int32 -> Ptr () -> IO ()

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

type TreeModelFilterModifyFunc

Arguments

 = TreeModel

model: the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row whose display values are determined

-> Int32

column: the column whose display value is determined

-> IO GValue

A function which calculates display values from raw values in the model. It must fill value with the display value for the column column in the row indicated by iter.

Since this function is called for each data access, it’s not a particularly efficient operation.

type TreeModelFilterModifyFunc_WithClosures

Arguments

 = TreeModel

model: the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row whose display values are determined

-> Int32

column: the column whose display value is determined

-> Ptr ()

data: user data given to gtk_tree_model_filter_set_modify_func()

-> IO GValue

A function which calculates display values from raw values in the model. It must fill value with the display value for the column column in the row indicated by iter.

Since this function is called for each data access, it’s not a particularly efficient operation.

drop_closures_TreeModelFilterModifyFunc :: TreeModelFilterModifyFunc -> TreeModelFilterModifyFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelFilterModifyFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)

=> FunPtr C_TreeModelFilterModifyFunc

-> a

model: the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row whose display values are determined

-> Int32

column: the column whose display value is determined

-> Ptr ()

data: user data given to gtk_tree_model_filter_set_modify_func()

-> m GValue

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

genClosure_TreeModelFilterModifyFunc :: MonadIO m => TreeModelFilterModifyFunc -> m (GClosure C_TreeModelFilterModifyFunc)

Wrap the callback into a GClosure.

mk_TreeModelFilterModifyFunc :: C_TreeModelFilterModifyFunc -> IO (FunPtr C_TreeModelFilterModifyFunc)

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

noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc

A convenience synonym for Nothing :: Maybe TreeModelFilterModifyFunc.

noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeModelFilterModifyFunc_WithClosures.

wrap_TreeModelFilterModifyFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterModifyFunc)) -> TreeModelFilterModifyFunc_WithClosures -> C_TreeModelFilterModifyFunc

Wrap a TreeModelFilterModifyFunc into a C_TreeModelFilterModifyFunc.

TreeModelFilterVisibleFunc

type C_TreeModelFilterVisibleFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

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

type TreeModelFilterVisibleFunc

Arguments

 = TreeModel

model: the child model of the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row in model whose visibility is determined

-> IO Bool

Returns: Whether the row indicated by iter is visible.

A function which decides whether the row indicated by iter is visible.

type TreeModelFilterVisibleFunc_WithClosures

Arguments

 = TreeModel

model: the child model of the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row in model whose visibility is determined

-> Ptr ()

data: user data given to treeModelFilterSetVisibleFunc

-> IO Bool

Returns: Whether the row indicated by iter is visible.

A function which decides whether the row indicated by iter is visible.

drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelFilterVisibleFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)

=> FunPtr C_TreeModelFilterVisibleFunc

-> a

model: the child model of the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row in model whose visibility is determined

-> Ptr ()

data: user data given to treeModelFilterSetVisibleFunc

-> m Bool

Returns: Whether the row indicated by iter is visible.

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

genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc)

Wrap the callback into a GClosure.

mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)

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

noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc

A convenience synonym for Nothing :: Maybe TreeModelFilterVisibleFunc.

noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeModelFilterVisibleFunc_WithClosures.

wrap_TreeModelFilterVisibleFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc)) -> TreeModelFilterVisibleFunc_WithClosures -> C_TreeModelFilterVisibleFunc

Wrap a TreeModelFilterVisibleFunc into a C_TreeModelFilterVisibleFunc.

TreeModelForeachFunc

type C_TreeModelForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt

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

type TreeModelForeachFunc

Arguments

 = TreeModel

model: the TreeModel being iterated

-> TreePath

path: the current TreePath

-> TreeIter

iter: the current TreeIter

-> IO Bool

Returns: True to stop iterating, False to continue

Type of the callback passed to treeModelForeach to iterate over the rows in a tree model.

type TreeModelForeachFunc_WithClosures

Arguments

 = TreeModel

model: the TreeModel being iterated

-> TreePath

path: the current TreePath

-> TreeIter

iter: the current TreeIter

-> Ptr ()

data: The user data passed to treeModelForeach

-> IO Bool

Returns: True to stop iterating, False to continue

Type of the callback passed to treeModelForeach to iterate over the rows in a tree model.

drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)

=> FunPtr C_TreeModelForeachFunc

-> a

model: the TreeModel being iterated

-> TreePath

path: the current TreePath

-> TreeIter

iter: the current TreeIter

-> Ptr ()

data: The user data passed to treeModelForeach

-> m Bool

Returns: True to stop iterating, False to continue

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

genClosure_TreeModelForeachFunc :: MonadIO m => TreeModelForeachFunc -> m (GClosure C_TreeModelForeachFunc)

Wrap the callback into a GClosure.

mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)

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

noTreeModelForeachFunc :: Maybe TreeModelForeachFunc

A convenience synonym for Nothing :: Maybe TreeModelForeachFunc.

noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeModelForeachFunc_WithClosures.

wrap_TreeModelForeachFunc :: Maybe (Ptr (FunPtr C_TreeModelForeachFunc)) -> TreeModelForeachFunc_WithClosures -> C_TreeModelForeachFunc

Wrap a TreeModelForeachFunc into a C_TreeModelForeachFunc.

TreeSelectionForeachFunc

type C_TreeSelectionForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()

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

type TreeSelectionForeachFunc

Arguments

 = TreeModel

model: The TreeModel being viewed

-> TreePath

path: The TreePath of a selected row

-> TreeIter

iter: A TreeIter pointing to a selected row

-> IO ()

A function used by treeSelectionSelectedForeach to map all selected rows. It will be called on every selected row in the view.

type TreeSelectionForeachFunc_WithClosures

Arguments

 = TreeModel

model: The TreeModel being viewed

-> TreePath

path: The TreePath of a selected row

-> TreeIter

iter: A TreeIter pointing to a selected row

-> Ptr ()

data: user data

-> IO ()

A function used by treeSelectionSelectedForeach to map all selected rows. It will be called on every selected row in the view.

drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeSelectionForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)

=> FunPtr C_TreeSelectionForeachFunc

-> a

model: The TreeModel being viewed

-> TreePath

path: The TreePath of a selected row

-> TreeIter

iter: A TreeIter pointing to a selected row

-> Ptr ()

data: user data

-> m ()

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

genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc)

Wrap the callback into a GClosure.

mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)

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

noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc

A convenience synonym for Nothing :: Maybe TreeSelectionForeachFunc.

noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeSelectionForeachFunc_WithClosures.

wrap_TreeSelectionForeachFunc :: Maybe (Ptr (FunPtr C_TreeSelectionForeachFunc)) -> TreeSelectionForeachFunc_WithClosures -> C_TreeSelectionForeachFunc

Wrap a TreeSelectionForeachFunc into a C_TreeSelectionForeachFunc.

TreeSelectionFunc

type C_TreeSelectionFunc = Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt

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

type TreeSelectionFunc

Arguments

 = TreeSelection

selection: A TreeSelection

-> TreeModel

model: A TreeModel being viewed

-> TreePath

path: The TreePath of the row in question

-> Bool

pathCurrentlySelected: True, if the path is currently selected

-> IO Bool

Returns: True, if the selection state of the row can be toggled

A function used by treeSelectionSetSelectFunction to filter whether or not a row may be selected. It is called whenever a row's state might change. A return value of True indicates to selection that it is okay to change the selection.

type TreeSelectionFunc_WithClosures

Arguments

 = TreeSelection

selection: A TreeSelection

-> TreeModel

model: A TreeModel being viewed

-> TreePath

path: The TreePath of the row in question

-> Bool

pathCurrentlySelected: True, if the path is currently selected

-> Ptr ()

data: user data

-> IO Bool

Returns: True, if the selection state of the row can be toggled

A function used by treeSelectionSetSelectFunction to filter whether or not a row may be selected. It is called whenever a row's state might change. A return value of True indicates to selection that it is okay to change the selection.

drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeSelectionFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b)

=> FunPtr C_TreeSelectionFunc

-> a

selection: A TreeSelection

-> b

model: A TreeModel being viewed

-> TreePath

path: The TreePath of the row in question

-> Bool

pathCurrentlySelected: True, if the path is currently selected

-> Ptr ()

data: user data

-> m Bool

Returns: True, if the selection state of the row can be toggled

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

genClosure_TreeSelectionFunc :: MonadIO m => TreeSelectionFunc -> m (GClosure C_TreeSelectionFunc)

Wrap the callback into a GClosure.

mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)

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

noTreeSelectionFunc :: Maybe TreeSelectionFunc

A convenience synonym for Nothing :: Maybe TreeSelectionFunc.

noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeSelectionFunc_WithClosures.

wrap_TreeSelectionFunc :: Maybe (Ptr (FunPtr C_TreeSelectionFunc)) -> TreeSelectionFunc_WithClosures -> C_TreeSelectionFunc

Wrap a TreeSelectionFunc into a C_TreeSelectionFunc.

TreeViewColumnDropFunc

type C_TreeViewColumnDropFunc = Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt

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

type TreeViewColumnDropFunc

Arguments

 = TreeView

treeView: A TreeView

-> TreeViewColumn

column: The TreeViewColumn being dragged

-> TreeViewColumn

prevColumn: A TreeViewColumn on one side of column

-> TreeViewColumn

nextColumn: A TreeViewColumn on the other side of column

-> IO Bool

Returns: True, if column can be dropped in this spot

Function type for determining whether column can be dropped in a particular spot (as determined by prevColumn and nextColumn). In left to right locales, prevColumn is on the left of the potential drop spot, and nextColumn is on the right. In right to left mode, this is reversed. This function should return True if the spot is a valid drop spot. Please note that returning True does not actually indicate that the column drop was made, but is meant only to indicate a possible drop spot to the user.

type TreeViewColumnDropFunc_WithClosures

Arguments

 = TreeView

treeView: A TreeView

-> TreeViewColumn

column: The TreeViewColumn being dragged

-> TreeViewColumn

prevColumn: A TreeViewColumn on one side of column

-> TreeViewColumn

nextColumn: A TreeViewColumn on the other side of column

-> Ptr ()

data: user data

-> IO Bool

Returns: True, if column can be dropped in this spot

Function type for determining whether column can be dropped in a particular spot (as determined by prevColumn and nextColumn). In left to right locales, prevColumn is on the left of the potential drop spot, and nextColumn is on the right. In right to left mode, this is reversed. This function should return True if the spot is a valid drop spot. Please note that returning True does not actually indicate that the column drop was made, but is meant only to indicate a possible drop spot to the user.

drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewColumnDropFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d)

=> FunPtr C_TreeViewColumnDropFunc

-> a

treeView: A TreeView

-> b

column: The TreeViewColumn being dragged

-> c

prevColumn: A TreeViewColumn on one side of column

-> d

nextColumn: A TreeViewColumn on the other side of column

-> Ptr ()

data: user data

-> m Bool

Returns: True, if column can be dropped in this spot

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

genClosure_TreeViewColumnDropFunc :: MonadIO m => TreeViewColumnDropFunc -> m (GClosure C_TreeViewColumnDropFunc)

Wrap the callback into a GClosure.

mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)

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

noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc

A convenience synonym for Nothing :: Maybe TreeViewColumnDropFunc.

noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeViewColumnDropFunc_WithClosures.

wrap_TreeViewColumnDropFunc :: Maybe (Ptr (FunPtr C_TreeViewColumnDropFunc)) -> TreeViewColumnDropFunc_WithClosures -> C_TreeViewColumnDropFunc

Wrap a TreeViewColumnDropFunc into a C_TreeViewColumnDropFunc.

TreeViewMappingFunc

type C_TreeViewMappingFunc = Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()

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

type TreeViewMappingFunc

Arguments

 = TreeView

treeView: A TreeView

-> TreePath

path: The path that’s expanded

-> IO ()

Function used for treeViewMapExpandedRows.

type TreeViewMappingFunc_WithClosures

Arguments

 = TreeView

treeView: A TreeView

-> TreePath

path: The path that’s expanded

-> Ptr ()

userData: user data

-> IO ()

Function used for treeViewMapExpandedRows.

drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewMappingFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeView a)

=> FunPtr C_TreeViewMappingFunc

-> a

treeView: A TreeView

-> TreePath

path: The path that’s expanded

-> Ptr ()

userData: user data

-> m ()

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

genClosure_TreeViewMappingFunc :: MonadIO m => TreeViewMappingFunc -> m (GClosure C_TreeViewMappingFunc)

Wrap the callback into a GClosure.

mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)

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

noTreeViewMappingFunc :: Maybe TreeViewMappingFunc

A convenience synonym for Nothing :: Maybe TreeViewMappingFunc.

noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeViewMappingFunc_WithClosures.

wrap_TreeViewMappingFunc :: Maybe (Ptr (FunPtr C_TreeViewMappingFunc)) -> TreeViewMappingFunc_WithClosures -> C_TreeViewMappingFunc

Wrap a TreeViewMappingFunc into a C_TreeViewMappingFunc.

TreeViewRowSeparatorFunc

type C_TreeViewRowSeparatorFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

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

type TreeViewRowSeparatorFunc

Arguments

 = TreeModel

model: the TreeModel

-> TreeIter

iter: a TreeIter pointing at a row in model

-> IO Bool

Returns: True if the row is a separator

Function type for determining whether the row pointed to by iter should be rendered as a separator. A common way to implement this is to have a boolean column in the model, whose values the TreeViewRowSeparatorFunc returns.

type TreeViewRowSeparatorFunc_WithClosures

Arguments

 = TreeModel

model: the TreeModel

-> TreeIter

iter: a TreeIter pointing at a row in model

-> Ptr ()

data: user data

-> IO Bool

Returns: True if the row is a separator

Function type for determining whether the row pointed to by iter should be rendered as a separator. A common way to implement this is to have a boolean column in the model, whose values the TreeViewRowSeparatorFunc returns.

drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewRowSeparatorFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)

=> FunPtr C_TreeViewRowSeparatorFunc

-> a

model: the TreeModel

-> TreeIter

iter: a TreeIter pointing at a row in model

-> Ptr ()

data: user data

-> m Bool

Returns: True if the row is a separator

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

genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc)

Wrap the callback into a GClosure.

mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)

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

noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc

A convenience synonym for Nothing :: Maybe TreeViewRowSeparatorFunc.

noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeViewRowSeparatorFunc_WithClosures.

wrap_TreeViewRowSeparatorFunc :: Maybe (Ptr (FunPtr C_TreeViewRowSeparatorFunc)) -> TreeViewRowSeparatorFunc_WithClosures -> C_TreeViewRowSeparatorFunc

Wrap a TreeViewRowSeparatorFunc into a C_TreeViewRowSeparatorFunc.

TreeViewSearchEqualFunc

type C_TreeViewSearchEqualFunc = Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

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

type TreeViewSearchEqualFunc

Arguments

 = TreeModel

model: the TreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

iter: a TreeIter pointing the row of model that should be compared with key.

-> IO Bool

Returns: False if the row matches, True otherwise.

A function used for checking whether a row in model matches a search key string entered by the user. Note the return value is reversed from what you would normally expect, though it has some similarity to strcmp() returning 0 for equal strings.

type TreeViewSearchEqualFunc_WithClosures

Arguments

 = TreeModel

model: the TreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

iter: a TreeIter pointing the row of model that should be compared with key.

-> Ptr ()

searchData: user data from treeViewSetSearchEqualFunc

-> IO Bool

Returns: False if the row matches, True otherwise.

A function used for checking whether a row in model matches a search key string entered by the user. Note the return value is reversed from what you would normally expect, though it has some similarity to strcmp() returning 0 for equal strings.

drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewSearchEqualFunc

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)

=> FunPtr C_TreeViewSearchEqualFunc

-> a

model: the TreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

iter: a TreeIter pointing the row of model that should be compared with key.

-> Ptr ()

searchData: user data from treeViewSetSearchEqualFunc

-> m Bool

Returns: False if the row matches, True otherwise.

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

genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc)

Wrap the callback into a GClosure.

mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)

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

noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc

A convenience synonym for Nothing :: Maybe TreeViewSearchEqualFunc.

noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeViewSearchEqualFunc_WithClosures.

wrap_TreeViewSearchEqualFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchEqualFunc)) -> TreeViewSearchEqualFunc_WithClosures -> C_TreeViewSearchEqualFunc

Wrap a TreeViewSearchEqualFunc into a C_TreeViewSearchEqualFunc.

TreeViewSearchPositionFunc

type C_TreeViewSearchPositionFunc = Ptr TreeView -> Ptr Widget -> Ptr () -> IO ()

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

type TreeViewSearchPositionFunc = TreeView -> Widget -> IO ()

No description available in the introspection data.

type TreeViewSearchPositionFunc_WithClosures = TreeView -> Widget -> Ptr () -> IO ()

No description available in the introspection data.

drop_closures_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> TreeViewSearchPositionFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewSearchPositionFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsWidget b) => FunPtr C_TreeViewSearchPositionFunc -> a -> b -> Ptr () -> m ()

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

genClosure_TreeViewSearchPositionFunc :: MonadIO m => TreeViewSearchPositionFunc -> m (GClosure C_TreeViewSearchPositionFunc)

Wrap the callback into a GClosure.

mk_TreeViewSearchPositionFunc :: C_TreeViewSearchPositionFunc -> IO (FunPtr C_TreeViewSearchPositionFunc)

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

noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc

A convenience synonym for Nothing :: Maybe TreeViewSearchPositionFunc.

noTreeViewSearchPositionFunc_WithClosures :: Maybe TreeViewSearchPositionFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeViewSearchPositionFunc_WithClosures.

wrap_TreeViewSearchPositionFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchPositionFunc)) -> TreeViewSearchPositionFunc_WithClosures -> C_TreeViewSearchPositionFunc

Wrap a TreeViewSearchPositionFunc into a C_TreeViewSearchPositionFunc.

WidgetClassAdjustBaselineAllocationFieldCallback

type C_WidgetClassAdjustBaselineAllocationFieldCallback = Ptr Widget -> Int32 -> IO ()

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

type WidgetClassAdjustBaselineAllocationFieldCallback = Widget -> Int32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassAdjustBaselineAllocationFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback -> a -> Int32 -> m ()

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

genClosure_WidgetClassAdjustBaselineAllocationFieldCallback :: MonadIO m => WidgetClassAdjustBaselineAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineAllocationFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassAdjustBaselineAllocationFieldCallback :: C_WidgetClassAdjustBaselineAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)

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

noWidgetClassAdjustBaselineAllocationFieldCallback :: Maybe WidgetClassAdjustBaselineAllocationFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassAdjustBaselineAllocationFieldCallback.

wrap_WidgetClassAdjustBaselineAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)) -> WidgetClassAdjustBaselineAllocationFieldCallback -> C_WidgetClassAdjustBaselineAllocationFieldCallback

Wrap a WidgetClassAdjustBaselineAllocationFieldCallback into a C_WidgetClassAdjustBaselineAllocationFieldCallback.

WidgetClassAdjustBaselineRequestFieldCallback

type C_WidgetClassAdjustBaselineRequestFieldCallback = Ptr Widget -> Int32 -> Int32 -> IO ()

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

type WidgetClassAdjustBaselineRequestFieldCallback = Widget -> Int32 -> Int32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassAdjustBaselineRequestFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> a -> Int32 -> Int32 -> m ()

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

genClosure_WidgetClassAdjustBaselineRequestFieldCallback :: MonadIO m => WidgetClassAdjustBaselineRequestFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineRequestFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassAdjustBaselineRequestFieldCallback :: C_WidgetClassAdjustBaselineRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)

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

noWidgetClassAdjustBaselineRequestFieldCallback :: Maybe WidgetClassAdjustBaselineRequestFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassAdjustBaselineRequestFieldCallback.

wrap_WidgetClassAdjustBaselineRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)) -> WidgetClassAdjustBaselineRequestFieldCallback -> C_WidgetClassAdjustBaselineRequestFieldCallback

Wrap a WidgetClassAdjustBaselineRequestFieldCallback into a C_WidgetClassAdjustBaselineRequestFieldCallback.

WidgetClassAdjustSizeAllocationFieldCallback

type C_WidgetClassAdjustSizeAllocationFieldCallback = Ptr Widget -> CUInt -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()

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

type WidgetClassAdjustSizeAllocationFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassAdjustSizeAllocationFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> a -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

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

genClosure_WidgetClassAdjustSizeAllocationFieldCallback :: MonadIO m => WidgetClassAdjustSizeAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustSizeAllocationFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassAdjustSizeAllocationFieldCallback :: C_WidgetClassAdjustSizeAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)

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

noWidgetClassAdjustSizeAllocationFieldCallback :: Maybe WidgetClassAdjustSizeAllocationFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassAdjustSizeAllocationFieldCallback.

wrap_WidgetClassAdjustSizeAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)) -> WidgetClassAdjustSizeAllocationFieldCallback -> C_WidgetClassAdjustSizeAllocationFieldCallback

Wrap a WidgetClassAdjustSizeAllocationFieldCallback into a C_WidgetClassAdjustSizeAllocationFieldCallback.

WidgetClassAdjustSizeRequestFieldCallback

type C_WidgetClassAdjustSizeRequestFieldCallback = Ptr Widget -> CUInt -> Int32 -> Int32 -> IO ()

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

type WidgetClassAdjustSizeRequestFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassAdjustSizeRequestFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> a -> Orientation -> Int32 -> Int32 -> m ()

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

genClosure_WidgetClassAdjustSizeRequestFieldCallback :: MonadIO m => WidgetClassAdjustSizeRequestFieldCallback -> m (GClosure C_WidgetClassAdjustSizeRequestFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassAdjustSizeRequestFieldCallback :: C_WidgetClassAdjustSizeRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)

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

noWidgetClassAdjustSizeRequestFieldCallback :: Maybe WidgetClassAdjustSizeRequestFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassAdjustSizeRequestFieldCallback.

wrap_WidgetClassAdjustSizeRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)) -> WidgetClassAdjustSizeRequestFieldCallback -> C_WidgetClassAdjustSizeRequestFieldCallback

Wrap a WidgetClassAdjustSizeRequestFieldCallback into a C_WidgetClassAdjustSizeRequestFieldCallback.

WidgetClassButtonPressEventFieldCallback

type C_WidgetClassButtonPressEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt

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

type WidgetClassButtonPressEventFieldCallback = Widget -> EventButton -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassButtonPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonPressEventFieldCallback -> a -> EventButton -> m Bool

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

genClosure_WidgetClassButtonPressEventFieldCallback :: MonadIO m => WidgetClassButtonPressEventFieldCallback -> m (GClosure C_WidgetClassButtonPressEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassButtonPressEventFieldCallback :: C_WidgetClassButtonPressEventFieldCallback -> IO (FunPtr C_WidgetClassButtonPressEventFieldCallback)

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

noWidgetClassButtonPressEventFieldCallback :: Maybe WidgetClassButtonPressEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassButtonPressEventFieldCallback.

wrap_WidgetClassButtonPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)) -> WidgetClassButtonPressEventFieldCallback -> C_WidgetClassButtonPressEventFieldCallback

Wrap a WidgetClassButtonPressEventFieldCallback into a C_WidgetClassButtonPressEventFieldCallback.

WidgetClassButtonReleaseEventFieldCallback

type C_WidgetClassButtonReleaseEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt

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

type WidgetClassButtonReleaseEventFieldCallback = Widget -> EventButton -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassButtonReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonReleaseEventFieldCallback -> a -> EventButton -> m Bool

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

genClosure_WidgetClassButtonReleaseEventFieldCallback :: MonadIO m => WidgetClassButtonReleaseEventFieldCallback -> m (GClosure C_WidgetClassButtonReleaseEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassButtonReleaseEventFieldCallback :: C_WidgetClassButtonReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)

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

noWidgetClassButtonReleaseEventFieldCallback :: Maybe WidgetClassButtonReleaseEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassButtonReleaseEventFieldCallback.

wrap_WidgetClassButtonReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)) -> WidgetClassButtonReleaseEventFieldCallback -> C_WidgetClassButtonReleaseEventFieldCallback

Wrap a WidgetClassButtonReleaseEventFieldCallback into a C_WidgetClassButtonReleaseEventFieldCallback.

WidgetClassCanActivateAccelFieldCallback

type C_WidgetClassCanActivateAccelFieldCallback = Ptr Widget -> Word32 -> IO CInt

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

type WidgetClassCanActivateAccelFieldCallback

Arguments

 = Widget

widget: a Widget

-> Word32

signalId: the ID of a signal installed on widget

-> IO Bool

Returns: True if the accelerator can be activated.

No description available in the introspection data.

dynamic_WidgetClassCanActivateAccelFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassCanActivateAccelFieldCallback

-> a

widget: a Widget

-> Word32

signalId: the ID of a signal installed on widget

-> m Bool

Returns: True if the accelerator can be activated.

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

genClosure_WidgetClassCanActivateAccelFieldCallback :: MonadIO m => WidgetClassCanActivateAccelFieldCallback -> m (GClosure C_WidgetClassCanActivateAccelFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassCanActivateAccelFieldCallback :: C_WidgetClassCanActivateAccelFieldCallback -> IO (FunPtr C_WidgetClassCanActivateAccelFieldCallback)

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

noWidgetClassCanActivateAccelFieldCallback :: Maybe WidgetClassCanActivateAccelFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassCanActivateAccelFieldCallback.

wrap_WidgetClassCanActivateAccelFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)) -> WidgetClassCanActivateAccelFieldCallback -> C_WidgetClassCanActivateAccelFieldCallback

Wrap a WidgetClassCanActivateAccelFieldCallback into a C_WidgetClassCanActivateAccelFieldCallback.

WidgetClassChildNotifyFieldCallback

type C_WidgetClassChildNotifyFieldCallback = Ptr Widget -> Ptr GParamSpec -> IO ()

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

type WidgetClassChildNotifyFieldCallback

Arguments

 = Widget

widget: a Widget

-> GParamSpec

childProperty: the name of a child property installed on the class of widget’s parent

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassChildNotifyFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassChildNotifyFieldCallback

-> a

widget: a Widget

-> GParamSpec

childProperty: the name of a child property installed on the class of widget’s parent

-> m ()

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

genClosure_WidgetClassChildNotifyFieldCallback :: MonadIO m => WidgetClassChildNotifyFieldCallback -> m (GClosure C_WidgetClassChildNotifyFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassChildNotifyFieldCallback :: C_WidgetClassChildNotifyFieldCallback -> IO (FunPtr C_WidgetClassChildNotifyFieldCallback)

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

noWidgetClassChildNotifyFieldCallback :: Maybe WidgetClassChildNotifyFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassChildNotifyFieldCallback.

wrap_WidgetClassChildNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassChildNotifyFieldCallback)) -> WidgetClassChildNotifyFieldCallback -> C_WidgetClassChildNotifyFieldCallback

Wrap a WidgetClassChildNotifyFieldCallback into a C_WidgetClassChildNotifyFieldCallback.

WidgetClassCompositedChangedFieldCallback

type C_WidgetClassCompositedChangedFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassCompositedChangedFieldCallback = Widget -> IO ()

No description available in the introspection data.

dynamic_WidgetClassCompositedChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCompositedChangedFieldCallback -> a -> m ()

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

genClosure_WidgetClassCompositedChangedFieldCallback :: MonadIO m => WidgetClassCompositedChangedFieldCallback -> m (GClosure C_WidgetClassCompositedChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassCompositedChangedFieldCallback :: C_WidgetClassCompositedChangedFieldCallback -> IO (FunPtr C_WidgetClassCompositedChangedFieldCallback)

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

noWidgetClassCompositedChangedFieldCallback :: Maybe WidgetClassCompositedChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassCompositedChangedFieldCallback.

wrap_WidgetClassCompositedChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCompositedChangedFieldCallback)) -> WidgetClassCompositedChangedFieldCallback -> C_WidgetClassCompositedChangedFieldCallback

Wrap a WidgetClassCompositedChangedFieldCallback into a C_WidgetClassCompositedChangedFieldCallback.

WidgetClassComputeExpandFieldCallback

type C_WidgetClassComputeExpandFieldCallback = Ptr Widget -> CInt -> CInt -> IO ()

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

type WidgetClassComputeExpandFieldCallback = Widget -> Bool -> Bool -> IO ()

No description available in the introspection data.

dynamic_WidgetClassComputeExpandFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassComputeExpandFieldCallback -> a -> Bool -> Bool -> m ()

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

genClosure_WidgetClassComputeExpandFieldCallback :: MonadIO m => WidgetClassComputeExpandFieldCallback -> m (GClosure C_WidgetClassComputeExpandFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassComputeExpandFieldCallback :: C_WidgetClassComputeExpandFieldCallback -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)

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

noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassComputeExpandFieldCallback.

wrap_WidgetClassComputeExpandFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)) -> WidgetClassComputeExpandFieldCallback -> C_WidgetClassComputeExpandFieldCallback

Wrap a WidgetClassComputeExpandFieldCallback into a C_WidgetClassComputeExpandFieldCallback.

WidgetClassConfigureEventFieldCallback

type C_WidgetClassConfigureEventFieldCallback = Ptr Widget -> Ptr EventConfigure -> IO CInt

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

type WidgetClassConfigureEventFieldCallback = Widget -> EventConfigure -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassConfigureEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassConfigureEventFieldCallback -> a -> EventConfigure -> m Bool

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

genClosure_WidgetClassConfigureEventFieldCallback :: MonadIO m => WidgetClassConfigureEventFieldCallback -> m (GClosure C_WidgetClassConfigureEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassConfigureEventFieldCallback :: C_WidgetClassConfigureEventFieldCallback -> IO (FunPtr C_WidgetClassConfigureEventFieldCallback)

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

noWidgetClassConfigureEventFieldCallback :: Maybe WidgetClassConfigureEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassConfigureEventFieldCallback.

wrap_WidgetClassConfigureEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassConfigureEventFieldCallback)) -> WidgetClassConfigureEventFieldCallback -> C_WidgetClassConfigureEventFieldCallback

Wrap a WidgetClassConfigureEventFieldCallback into a C_WidgetClassConfigureEventFieldCallback.

WidgetClassDamageEventFieldCallback

type C_WidgetClassDamageEventFieldCallback = Ptr Widget -> Ptr EventExpose -> IO CInt

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

type WidgetClassDamageEventFieldCallback = Widget -> EventExpose -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassDamageEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDamageEventFieldCallback -> a -> EventExpose -> m Bool

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

genClosure_WidgetClassDamageEventFieldCallback :: MonadIO m => WidgetClassDamageEventFieldCallback -> m (GClosure C_WidgetClassDamageEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDamageEventFieldCallback :: C_WidgetClassDamageEventFieldCallback -> IO (FunPtr C_WidgetClassDamageEventFieldCallback)

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

noWidgetClassDamageEventFieldCallback :: Maybe WidgetClassDamageEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDamageEventFieldCallback.

wrap_WidgetClassDamageEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDamageEventFieldCallback)) -> WidgetClassDamageEventFieldCallback -> C_WidgetClassDamageEventFieldCallback

Wrap a WidgetClassDamageEventFieldCallback into a C_WidgetClassDamageEventFieldCallback.

WidgetClassDeleteEventFieldCallback

type C_WidgetClassDeleteEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

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

type WidgetClassDeleteEventFieldCallback = Widget -> EventAny -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassDeleteEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDeleteEventFieldCallback -> a -> EventAny -> m Bool

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

genClosure_WidgetClassDeleteEventFieldCallback :: MonadIO m => WidgetClassDeleteEventFieldCallback -> m (GClosure C_WidgetClassDeleteEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDeleteEventFieldCallback :: C_WidgetClassDeleteEventFieldCallback -> IO (FunPtr C_WidgetClassDeleteEventFieldCallback)

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

noWidgetClassDeleteEventFieldCallback :: Maybe WidgetClassDeleteEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDeleteEventFieldCallback.

wrap_WidgetClassDeleteEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)) -> WidgetClassDeleteEventFieldCallback -> C_WidgetClassDeleteEventFieldCallback

Wrap a WidgetClassDeleteEventFieldCallback into a C_WidgetClassDeleteEventFieldCallback.

WidgetClassDestroyEventFieldCallback

type C_WidgetClassDestroyEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

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

type WidgetClassDestroyEventFieldCallback = Widget -> EventAny -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassDestroyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDestroyEventFieldCallback -> a -> EventAny -> m Bool

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

genClosure_WidgetClassDestroyEventFieldCallback :: MonadIO m => WidgetClassDestroyEventFieldCallback -> m (GClosure C_WidgetClassDestroyEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDestroyEventFieldCallback :: C_WidgetClassDestroyEventFieldCallback -> IO (FunPtr C_WidgetClassDestroyEventFieldCallback)

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

noWidgetClassDestroyEventFieldCallback :: Maybe WidgetClassDestroyEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDestroyEventFieldCallback.

wrap_WidgetClassDestroyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyEventFieldCallback)) -> WidgetClassDestroyEventFieldCallback -> C_WidgetClassDestroyEventFieldCallback

Wrap a WidgetClassDestroyEventFieldCallback into a C_WidgetClassDestroyEventFieldCallback.

WidgetClassDestroyFieldCallback

type C_WidgetClassDestroyFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassDestroyFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassDestroyFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassDestroyFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassDestroyFieldCallback :: MonadIO m => WidgetClassDestroyFieldCallback -> m (GClosure C_WidgetClassDestroyFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDestroyFieldCallback :: C_WidgetClassDestroyFieldCallback -> IO (FunPtr C_WidgetClassDestroyFieldCallback)

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

noWidgetClassDestroyFieldCallback :: Maybe WidgetClassDestroyFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDestroyFieldCallback.

wrap_WidgetClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyFieldCallback)) -> WidgetClassDestroyFieldCallback -> C_WidgetClassDestroyFieldCallback

Wrap a WidgetClassDestroyFieldCallback into a C_WidgetClassDestroyFieldCallback.

WidgetClassDirectionChangedFieldCallback

type C_WidgetClassDirectionChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

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

type WidgetClassDirectionChangedFieldCallback = Widget -> TextDirection -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDirectionChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDirectionChangedFieldCallback -> a -> TextDirection -> m ()

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

genClosure_WidgetClassDirectionChangedFieldCallback :: MonadIO m => WidgetClassDirectionChangedFieldCallback -> m (GClosure C_WidgetClassDirectionChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDirectionChangedFieldCallback :: C_WidgetClassDirectionChangedFieldCallback -> IO (FunPtr C_WidgetClassDirectionChangedFieldCallback)

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

noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDirectionChangedFieldCallback.

wrap_WidgetClassDirectionChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDirectionChangedFieldCallback)) -> WidgetClassDirectionChangedFieldCallback -> C_WidgetClassDirectionChangedFieldCallback

Wrap a WidgetClassDirectionChangedFieldCallback into a C_WidgetClassDirectionChangedFieldCallback.

WidgetClassDispatchChildPropertiesChangedFieldCallback

type C_WidgetClassDispatchChildPropertiesChangedFieldCallback = Ptr Widget -> Word32 -> Ptr GParamSpec -> IO ()

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

type WidgetClassDispatchChildPropertiesChangedFieldCallback = Widget -> Word32 -> GParamSpec -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDispatchChildPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()

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

genClosure_WidgetClassDispatchChildPropertiesChangedFieldCallback :: MonadIO m => WidgetClassDispatchChildPropertiesChangedFieldCallback -> m (GClosure C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDispatchChildPropertiesChangedFieldCallback :: C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> IO (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

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

noWidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback.

wrap_WidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)) -> WidgetClassDispatchChildPropertiesChangedFieldCallback -> C_WidgetClassDispatchChildPropertiesChangedFieldCallback

Wrap a WidgetClassDispatchChildPropertiesChangedFieldCallback into a C_WidgetClassDispatchChildPropertiesChangedFieldCallback.

WidgetClassDragBeginFieldCallback

type C_WidgetClassDragBeginFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()

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

type WidgetClassDragBeginFieldCallback = Widget -> DragContext -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDragBeginFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassDragBeginFieldCallback :: MonadIO m => WidgetClassDragBeginFieldCallback -> m (GClosure C_WidgetClassDragBeginFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragBeginFieldCallback :: C_WidgetClassDragBeginFieldCallback -> IO (FunPtr C_WidgetClassDragBeginFieldCallback)

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

noWidgetClassDragBeginFieldCallback :: Maybe WidgetClassDragBeginFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragBeginFieldCallback.

wrap_WidgetClassDragBeginFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)) -> WidgetClassDragBeginFieldCallback -> C_WidgetClassDragBeginFieldCallback

Wrap a WidgetClassDragBeginFieldCallback into a C_WidgetClassDragBeginFieldCallback.

WidgetClassDragDataDeleteFieldCallback

type C_WidgetClassDragDataDeleteFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()

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

type WidgetClassDragDataDeleteFieldCallback = Widget -> DragContext -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDragDataDeleteFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataDeleteFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassDragDataDeleteFieldCallback :: MonadIO m => WidgetClassDragDataDeleteFieldCallback -> m (GClosure C_WidgetClassDragDataDeleteFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragDataDeleteFieldCallback :: C_WidgetClassDragDataDeleteFieldCallback -> IO (FunPtr C_WidgetClassDragDataDeleteFieldCallback)

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

noWidgetClassDragDataDeleteFieldCallback :: Maybe WidgetClassDragDataDeleteFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragDataDeleteFieldCallback.

wrap_WidgetClassDragDataDeleteFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataDeleteFieldCallback)) -> WidgetClassDragDataDeleteFieldCallback -> C_WidgetClassDragDataDeleteFieldCallback

Wrap a WidgetClassDragDataDeleteFieldCallback into a C_WidgetClassDragDataDeleteFieldCallback.

WidgetClassDragDataGetFieldCallback

type C_WidgetClassDragDataGetFieldCallback = Ptr Widget -> Ptr DragContext -> Ptr SelectionData -> Word32 -> Word32 -> IO ()

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

type WidgetClassDragDataGetFieldCallback = Widget -> DragContext -> SelectionData -> Word32 -> Word32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDragDataGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataGetFieldCallback -> a -> b -> SelectionData -> Word32 -> Word32 -> m ()

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

genClosure_WidgetClassDragDataGetFieldCallback :: MonadIO m => WidgetClassDragDataGetFieldCallback -> m (GClosure C_WidgetClassDragDataGetFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragDataGetFieldCallback :: C_WidgetClassDragDataGetFieldCallback -> IO (FunPtr C_WidgetClassDragDataGetFieldCallback)

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

noWidgetClassDragDataGetFieldCallback :: Maybe WidgetClassDragDataGetFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragDataGetFieldCallback.

wrap_WidgetClassDragDataGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)) -> WidgetClassDragDataGetFieldCallback -> C_WidgetClassDragDataGetFieldCallback

Wrap a WidgetClassDragDataGetFieldCallback into a C_WidgetClassDragDataGetFieldCallback.

WidgetClassDragDataReceivedFieldCallback

type C_WidgetClassDragDataReceivedFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Ptr SelectionData -> Word32 -> Word32 -> IO ()

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

type WidgetClassDragDataReceivedFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDragDataReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataReceivedFieldCallback -> a -> b -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> m ()

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

genClosure_WidgetClassDragDataReceivedFieldCallback :: MonadIO m => WidgetClassDragDataReceivedFieldCallback -> m (GClosure C_WidgetClassDragDataReceivedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragDataReceivedFieldCallback :: C_WidgetClassDragDataReceivedFieldCallback -> IO (FunPtr C_WidgetClassDragDataReceivedFieldCallback)

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

noWidgetClassDragDataReceivedFieldCallback :: Maybe WidgetClassDragDataReceivedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragDataReceivedFieldCallback.

wrap_WidgetClassDragDataReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)) -> WidgetClassDragDataReceivedFieldCallback -> C_WidgetClassDragDataReceivedFieldCallback

Wrap a WidgetClassDragDataReceivedFieldCallback into a C_WidgetClassDragDataReceivedFieldCallback.

WidgetClassDragDropFieldCallback

type C_WidgetClassDragDropFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt

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

type WidgetClassDragDropFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassDragDropFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDropFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool

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

genClosure_WidgetClassDragDropFieldCallback :: MonadIO m => WidgetClassDragDropFieldCallback -> m (GClosure C_WidgetClassDragDropFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragDropFieldCallback :: C_WidgetClassDragDropFieldCallback -> IO (FunPtr C_WidgetClassDragDropFieldCallback)

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

noWidgetClassDragDropFieldCallback :: Maybe WidgetClassDragDropFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragDropFieldCallback.

wrap_WidgetClassDragDropFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDropFieldCallback)) -> WidgetClassDragDropFieldCallback -> C_WidgetClassDragDropFieldCallback

Wrap a WidgetClassDragDropFieldCallback into a C_WidgetClassDragDropFieldCallback.

WidgetClassDragEndFieldCallback

type C_WidgetClassDragEndFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()

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

type WidgetClassDragEndFieldCallback = Widget -> DragContext -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDragEndFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragEndFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassDragEndFieldCallback :: MonadIO m => WidgetClassDragEndFieldCallback -> m (GClosure C_WidgetClassDragEndFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragEndFieldCallback :: C_WidgetClassDragEndFieldCallback -> IO (FunPtr C_WidgetClassDragEndFieldCallback)

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

noWidgetClassDragEndFieldCallback :: Maybe WidgetClassDragEndFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragEndFieldCallback.

wrap_WidgetClassDragEndFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragEndFieldCallback)) -> WidgetClassDragEndFieldCallback -> C_WidgetClassDragEndFieldCallback

Wrap a WidgetClassDragEndFieldCallback into a C_WidgetClassDragEndFieldCallback.

WidgetClassDragFailedFieldCallback

type C_WidgetClassDragFailedFieldCallback = Ptr Widget -> Ptr DragContext -> CUInt -> IO CInt

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

type WidgetClassDragFailedFieldCallback = Widget -> DragContext -> DragResult -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassDragFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragFailedFieldCallback -> a -> b -> DragResult -> m Bool

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

genClosure_WidgetClassDragFailedFieldCallback :: MonadIO m => WidgetClassDragFailedFieldCallback -> m (GClosure C_WidgetClassDragFailedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragFailedFieldCallback :: C_WidgetClassDragFailedFieldCallback -> IO (FunPtr C_WidgetClassDragFailedFieldCallback)

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

noWidgetClassDragFailedFieldCallback :: Maybe WidgetClassDragFailedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragFailedFieldCallback.

wrap_WidgetClassDragFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)) -> WidgetClassDragFailedFieldCallback -> C_WidgetClassDragFailedFieldCallback

Wrap a WidgetClassDragFailedFieldCallback into a C_WidgetClassDragFailedFieldCallback.

WidgetClassDragLeaveFieldCallback

type C_WidgetClassDragLeaveFieldCallback = Ptr Widget -> Ptr DragContext -> Word32 -> IO ()

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

type WidgetClassDragLeaveFieldCallback = Widget -> DragContext -> Word32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassDragLeaveFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragLeaveFieldCallback -> a -> b -> Word32 -> m ()

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

genClosure_WidgetClassDragLeaveFieldCallback :: MonadIO m => WidgetClassDragLeaveFieldCallback -> m (GClosure C_WidgetClassDragLeaveFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragLeaveFieldCallback :: C_WidgetClassDragLeaveFieldCallback -> IO (FunPtr C_WidgetClassDragLeaveFieldCallback)

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

noWidgetClassDragLeaveFieldCallback :: Maybe WidgetClassDragLeaveFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragLeaveFieldCallback.

wrap_WidgetClassDragLeaveFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)) -> WidgetClassDragLeaveFieldCallback -> C_WidgetClassDragLeaveFieldCallback

Wrap a WidgetClassDragLeaveFieldCallback into a C_WidgetClassDragLeaveFieldCallback.

WidgetClassDragMotionFieldCallback

type C_WidgetClassDragMotionFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt

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

type WidgetClassDragMotionFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassDragMotionFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragMotionFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool

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

genClosure_WidgetClassDragMotionFieldCallback :: MonadIO m => WidgetClassDragMotionFieldCallback -> m (GClosure C_WidgetClassDragMotionFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDragMotionFieldCallback :: C_WidgetClassDragMotionFieldCallback -> IO (FunPtr C_WidgetClassDragMotionFieldCallback)

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

noWidgetClassDragMotionFieldCallback :: Maybe WidgetClassDragMotionFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDragMotionFieldCallback.

wrap_WidgetClassDragMotionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)) -> WidgetClassDragMotionFieldCallback -> C_WidgetClassDragMotionFieldCallback

Wrap a WidgetClassDragMotionFieldCallback into a C_WidgetClassDragMotionFieldCallback.

WidgetClassDrawFieldCallback

type C_WidgetClassDrawFieldCallback = Ptr Widget -> Ptr Context -> IO CInt

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

type WidgetClassDrawFieldCallback = Widget -> Context -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassDrawFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDrawFieldCallback -> a -> Context -> m Bool

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

genClosure_WidgetClassDrawFieldCallback :: MonadIO m => WidgetClassDrawFieldCallback -> m (GClosure C_WidgetClassDrawFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassDrawFieldCallback :: C_WidgetClassDrawFieldCallback -> IO (FunPtr C_WidgetClassDrawFieldCallback)

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

noWidgetClassDrawFieldCallback :: Maybe WidgetClassDrawFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassDrawFieldCallback.

wrap_WidgetClassDrawFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDrawFieldCallback)) -> WidgetClassDrawFieldCallback -> C_WidgetClassDrawFieldCallback

Wrap a WidgetClassDrawFieldCallback into a C_WidgetClassDrawFieldCallback.

WidgetClassEnterNotifyEventFieldCallback

type C_WidgetClassEnterNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt

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

type WidgetClassEnterNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassEnterNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> a -> EventCrossing -> m Bool

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

genClosure_WidgetClassEnterNotifyEventFieldCallback :: MonadIO m => WidgetClassEnterNotifyEventFieldCallback -> m (GClosure C_WidgetClassEnterNotifyEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassEnterNotifyEventFieldCallback :: C_WidgetClassEnterNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)

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

noWidgetClassEnterNotifyEventFieldCallback :: Maybe WidgetClassEnterNotifyEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassEnterNotifyEventFieldCallback.

wrap_WidgetClassEnterNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)) -> WidgetClassEnterNotifyEventFieldCallback -> C_WidgetClassEnterNotifyEventFieldCallback

Wrap a WidgetClassEnterNotifyEventFieldCallback into a C_WidgetClassEnterNotifyEventFieldCallback.

WidgetClassEventFieldCallback

type C_WidgetClassEventFieldCallback = Ptr Widget -> Ptr Event -> IO CInt

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

type WidgetClassEventFieldCallback

Arguments

 = Widget

widget: a Widget

-> Event

event: a Event

-> IO Bool

Returns: return from the event signal emission (True if the event was handled)

No description available in the introspection data.

dynamic_WidgetClassEventFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassEventFieldCallback

-> a

widget: a Widget

-> Event

event: a Event

-> m Bool

Returns: return from the event signal emission (True if the event was handled)

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

genClosure_WidgetClassEventFieldCallback :: MonadIO m => WidgetClassEventFieldCallback -> m (GClosure C_WidgetClassEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassEventFieldCallback :: C_WidgetClassEventFieldCallback -> IO (FunPtr C_WidgetClassEventFieldCallback)

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

noWidgetClassEventFieldCallback :: Maybe WidgetClassEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassEventFieldCallback.

wrap_WidgetClassEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEventFieldCallback)) -> WidgetClassEventFieldCallback -> C_WidgetClassEventFieldCallback

Wrap a WidgetClassEventFieldCallback into a C_WidgetClassEventFieldCallback.

WidgetClassFocusFieldCallback

type C_WidgetClassFocusFieldCallback = Ptr Widget -> CUInt -> IO CInt

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

type WidgetClassFocusFieldCallback = Widget -> DirectionType -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusFieldCallback -> a -> DirectionType -> m Bool

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

genClosure_WidgetClassFocusFieldCallback :: MonadIO m => WidgetClassFocusFieldCallback -> m (GClosure C_WidgetClassFocusFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassFocusFieldCallback :: C_WidgetClassFocusFieldCallback -> IO (FunPtr C_WidgetClassFocusFieldCallback)

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

noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassFocusFieldCallback.

wrap_WidgetClassFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusFieldCallback)) -> WidgetClassFocusFieldCallback -> C_WidgetClassFocusFieldCallback

Wrap a WidgetClassFocusFieldCallback into a C_WidgetClassFocusFieldCallback.

WidgetClassFocusInEventFieldCallback

type C_WidgetClassFocusInEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt

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

type WidgetClassFocusInEventFieldCallback = Widget -> EventFocus -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassFocusInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusInEventFieldCallback -> a -> EventFocus -> m Bool

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

genClosure_WidgetClassFocusInEventFieldCallback :: MonadIO m => WidgetClassFocusInEventFieldCallback -> m (GClosure C_WidgetClassFocusInEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassFocusInEventFieldCallback :: C_WidgetClassFocusInEventFieldCallback -> IO (FunPtr C_WidgetClassFocusInEventFieldCallback)

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

noWidgetClassFocusInEventFieldCallback :: Maybe WidgetClassFocusInEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassFocusInEventFieldCallback.

wrap_WidgetClassFocusInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)) -> WidgetClassFocusInEventFieldCallback -> C_WidgetClassFocusInEventFieldCallback

Wrap a WidgetClassFocusInEventFieldCallback into a C_WidgetClassFocusInEventFieldCallback.

WidgetClassFocusOutEventFieldCallback

type C_WidgetClassFocusOutEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt

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

type WidgetClassFocusOutEventFieldCallback = Widget -> EventFocus -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassFocusOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusOutEventFieldCallback -> a -> EventFocus -> m Bool

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

genClosure_WidgetClassFocusOutEventFieldCallback :: MonadIO m => WidgetClassFocusOutEventFieldCallback -> m (GClosure C_WidgetClassFocusOutEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassFocusOutEventFieldCallback :: C_WidgetClassFocusOutEventFieldCallback -> IO (FunPtr C_WidgetClassFocusOutEventFieldCallback)

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

noWidgetClassFocusOutEventFieldCallback :: Maybe WidgetClassFocusOutEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassFocusOutEventFieldCallback.

wrap_WidgetClassFocusOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusOutEventFieldCallback)) -> WidgetClassFocusOutEventFieldCallback -> C_WidgetClassFocusOutEventFieldCallback

Wrap a WidgetClassFocusOutEventFieldCallback into a C_WidgetClassFocusOutEventFieldCallback.

WidgetClassGetAccessibleFieldCallback

type C_WidgetClassGetAccessibleFieldCallback = Ptr Widget -> IO (Ptr Object)

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

type WidgetClassGetAccessibleFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO Object

Returns: the Object associated with widget

No description available in the introspection data.

dynamic_WidgetClassGetAccessibleFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetAccessibleFieldCallback

-> a

widget: a Widget

-> m Object

Returns: the Object associated with widget

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

genClosure_WidgetClassGetAccessibleFieldCallback :: MonadIO m => WidgetClassGetAccessibleFieldCallback -> m (GClosure C_WidgetClassGetAccessibleFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGetAccessibleFieldCallback :: C_WidgetClassGetAccessibleFieldCallback -> IO (FunPtr C_WidgetClassGetAccessibleFieldCallback)

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

noWidgetClassGetAccessibleFieldCallback :: Maybe WidgetClassGetAccessibleFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGetAccessibleFieldCallback.

wrap_WidgetClassGetAccessibleFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)) -> WidgetClassGetAccessibleFieldCallback -> C_WidgetClassGetAccessibleFieldCallback

Wrap a WidgetClassGetAccessibleFieldCallback into a C_WidgetClassGetAccessibleFieldCallback.

WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

type C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

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

type WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

Arguments

 = Widget

widget: a Widget instance

-> Int32

width: the width which is available for allocation, or -1 if none

-> IO (Int32, Int32, Int32, Int32)

No description available in the introspection data.

dynamic_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

-> a

widget: a Widget instance

-> Int32

width: the width which is available for allocation, or -1 if none

-> m (Int32, Int32, Int32, Int32)

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

genClosure_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

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

noWidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback.

wrap_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)) -> WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

Wrap a WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback into a C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback.

WidgetClassGetPreferredHeightFieldCallback

type C_WidgetClassGetPreferredHeightFieldCallback = Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()

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

type WidgetClassGetPreferredHeightFieldCallback

Arguments

 = Widget

widget: a Widget instance

-> IO (Int32, Int32)

No description available in the introspection data.

dynamic_WidgetClassGetPreferredHeightFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetPreferredHeightFieldCallback

-> a

widget: a Widget instance

-> m (Int32, Int32)

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

genClosure_WidgetClassGetPreferredHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGetPreferredHeightFieldCallback :: C_WidgetClassGetPreferredHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)

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

noWidgetClassGetPreferredHeightFieldCallback :: Maybe WidgetClassGetPreferredHeightFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGetPreferredHeightFieldCallback.

wrap_WidgetClassGetPreferredHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)) -> WidgetClassGetPreferredHeightFieldCallback -> C_WidgetClassGetPreferredHeightFieldCallback

Wrap a WidgetClassGetPreferredHeightFieldCallback into a C_WidgetClassGetPreferredHeightFieldCallback.

WidgetClassGetPreferredHeightForWidthFieldCallback

type C_WidgetClassGetPreferredHeightForWidthFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

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

type WidgetClassGetPreferredHeightForWidthFieldCallback

Arguments

 = Widget

widget: a Widget instance

-> Int32

width: the width which is available for allocation

-> IO (Int32, Int32)

No description available in the introspection data.

dynamic_WidgetClassGetPreferredHeightForWidthFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback

-> a

widget: a Widget instance

-> Int32

width: the width which is available for allocation

-> m (Int32, Int32)

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

genClosure_WidgetClassGetPreferredHeightForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightForWidthFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGetPreferredHeightForWidthFieldCallback :: C_WidgetClassGetPreferredHeightForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)

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

noWidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightForWidthFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGetPreferredHeightForWidthFieldCallback.

wrap_WidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)) -> WidgetClassGetPreferredHeightForWidthFieldCallback -> C_WidgetClassGetPreferredHeightForWidthFieldCallback

Wrap a WidgetClassGetPreferredHeightForWidthFieldCallback into a C_WidgetClassGetPreferredHeightForWidthFieldCallback.

WidgetClassGetPreferredWidthFieldCallback

type C_WidgetClassGetPreferredWidthFieldCallback = Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()

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

type WidgetClassGetPreferredWidthFieldCallback

Arguments

 = Widget

widget: a Widget instance

-> IO (Int32, Int32)

No description available in the introspection data.

dynamic_WidgetClassGetPreferredWidthFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetPreferredWidthFieldCallback

-> a

widget: a Widget instance

-> m (Int32, Int32)

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

genClosure_WidgetClassGetPreferredWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGetPreferredWidthFieldCallback :: C_WidgetClassGetPreferredWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)

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

noWidgetClassGetPreferredWidthFieldCallback :: Maybe WidgetClassGetPreferredWidthFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGetPreferredWidthFieldCallback.

wrap_WidgetClassGetPreferredWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)) -> WidgetClassGetPreferredWidthFieldCallback -> C_WidgetClassGetPreferredWidthFieldCallback

Wrap a WidgetClassGetPreferredWidthFieldCallback into a C_WidgetClassGetPreferredWidthFieldCallback.

WidgetClassGetPreferredWidthForHeightFieldCallback

type C_WidgetClassGetPreferredWidthForHeightFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

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

type WidgetClassGetPreferredWidthForHeightFieldCallback

Arguments

 = Widget

widget: a Widget instance

-> Int32

height: the height which is available for allocation

-> IO (Int32, Int32)

No description available in the introspection data.

dynamic_WidgetClassGetPreferredWidthForHeightFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback

-> a

widget: a Widget instance

-> Int32

height: the height which is available for allocation

-> m (Int32, Int32)

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

genClosure_WidgetClassGetPreferredWidthForHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthForHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthForHeightFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGetPreferredWidthForHeightFieldCallback :: C_WidgetClassGetPreferredWidthForHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)

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

noWidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe WidgetClassGetPreferredWidthForHeightFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGetPreferredWidthForHeightFieldCallback.

wrap_WidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)) -> WidgetClassGetPreferredWidthForHeightFieldCallback -> C_WidgetClassGetPreferredWidthForHeightFieldCallback

Wrap a WidgetClassGetPreferredWidthForHeightFieldCallback into a C_WidgetClassGetPreferredWidthForHeightFieldCallback.

WidgetClassGetRequestModeFieldCallback

type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt

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

type WidgetClassGetRequestModeFieldCallback

Arguments

 = Widget

widget: a Widget instance

-> IO SizeRequestMode

Returns: The SizeRequestMode preferred by widget.

No description available in the introspection data.

dynamic_WidgetClassGetRequestModeFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetRequestModeFieldCallback

-> a

widget: a Widget instance

-> m SizeRequestMode

Returns: The SizeRequestMode preferred by widget.

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

genClosure_WidgetClassGetRequestModeFieldCallback :: MonadIO m => WidgetClassGetRequestModeFieldCallback -> m (GClosure C_WidgetClassGetRequestModeFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGetRequestModeFieldCallback :: C_WidgetClassGetRequestModeFieldCallback -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)

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

noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGetRequestModeFieldCallback.

wrap_WidgetClassGetRequestModeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)) -> WidgetClassGetRequestModeFieldCallback -> C_WidgetClassGetRequestModeFieldCallback

Wrap a WidgetClassGetRequestModeFieldCallback into a C_WidgetClassGetRequestModeFieldCallback.

WidgetClassGrabBrokenEventFieldCallback

type C_WidgetClassGrabBrokenEventFieldCallback = Ptr Widget -> Ptr EventGrabBroken -> IO CInt

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

type WidgetClassGrabBrokenEventFieldCallback = Widget -> EventGrabBroken -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassGrabBrokenEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> a -> EventGrabBroken -> m Bool

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

genClosure_WidgetClassGrabBrokenEventFieldCallback :: MonadIO m => WidgetClassGrabBrokenEventFieldCallback -> m (GClosure C_WidgetClassGrabBrokenEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGrabBrokenEventFieldCallback :: C_WidgetClassGrabBrokenEventFieldCallback -> IO (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)

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

noWidgetClassGrabBrokenEventFieldCallback :: Maybe WidgetClassGrabBrokenEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGrabBrokenEventFieldCallback.

wrap_WidgetClassGrabBrokenEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)) -> WidgetClassGrabBrokenEventFieldCallback -> C_WidgetClassGrabBrokenEventFieldCallback

Wrap a WidgetClassGrabBrokenEventFieldCallback into a C_WidgetClassGrabBrokenEventFieldCallback.

WidgetClassGrabFocusFieldCallback

type C_WidgetClassGrabFocusFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassGrabFocusFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassGrabFocusFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGrabFocusFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassGrabFocusFieldCallback :: MonadIO m => WidgetClassGrabFocusFieldCallback -> m (GClosure C_WidgetClassGrabFocusFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGrabFocusFieldCallback :: C_WidgetClassGrabFocusFieldCallback -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)

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

noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGrabFocusFieldCallback.

wrap_WidgetClassGrabFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)) -> WidgetClassGrabFocusFieldCallback -> C_WidgetClassGrabFocusFieldCallback

Wrap a WidgetClassGrabFocusFieldCallback into a C_WidgetClassGrabFocusFieldCallback.

WidgetClassGrabNotifyFieldCallback

type C_WidgetClassGrabNotifyFieldCallback = Ptr Widget -> CInt -> IO ()

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

type WidgetClassGrabNotifyFieldCallback = Widget -> Bool -> IO ()

No description available in the introspection data.

dynamic_WidgetClassGrabNotifyFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabNotifyFieldCallback -> a -> Bool -> m ()

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

genClosure_WidgetClassGrabNotifyFieldCallback :: MonadIO m => WidgetClassGrabNotifyFieldCallback -> m (GClosure C_WidgetClassGrabNotifyFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassGrabNotifyFieldCallback :: C_WidgetClassGrabNotifyFieldCallback -> IO (FunPtr C_WidgetClassGrabNotifyFieldCallback)

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

noWidgetClassGrabNotifyFieldCallback :: Maybe WidgetClassGrabNotifyFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassGrabNotifyFieldCallback.

wrap_WidgetClassGrabNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)) -> WidgetClassGrabNotifyFieldCallback -> C_WidgetClassGrabNotifyFieldCallback

Wrap a WidgetClassGrabNotifyFieldCallback into a C_WidgetClassGrabNotifyFieldCallback.

WidgetClassHideFieldCallback

type C_WidgetClassHideFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassHideFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassHideFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassHideFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassHideFieldCallback :: MonadIO m => WidgetClassHideFieldCallback -> m (GClosure C_WidgetClassHideFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassHideFieldCallback :: C_WidgetClassHideFieldCallback -> IO (FunPtr C_WidgetClassHideFieldCallback)

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

noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassHideFieldCallback.

wrap_WidgetClassHideFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHideFieldCallback)) -> WidgetClassHideFieldCallback -> C_WidgetClassHideFieldCallback

Wrap a WidgetClassHideFieldCallback into a C_WidgetClassHideFieldCallback.

WidgetClassHierarchyChangedFieldCallback

type C_WidgetClassHierarchyChangedFieldCallback = Ptr Widget -> Ptr Widget -> IO ()

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

type WidgetClassHierarchyChangedFieldCallback = Widget -> Widget -> IO ()

No description available in the introspection data.

dynamic_WidgetClassHierarchyChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassHierarchyChangedFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassHierarchyChangedFieldCallback :: MonadIO m => WidgetClassHierarchyChangedFieldCallback -> m (GClosure C_WidgetClassHierarchyChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassHierarchyChangedFieldCallback :: C_WidgetClassHierarchyChangedFieldCallback -> IO (FunPtr C_WidgetClassHierarchyChangedFieldCallback)

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

noWidgetClassHierarchyChangedFieldCallback :: Maybe WidgetClassHierarchyChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassHierarchyChangedFieldCallback.

wrap_WidgetClassHierarchyChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHierarchyChangedFieldCallback)) -> WidgetClassHierarchyChangedFieldCallback -> C_WidgetClassHierarchyChangedFieldCallback

Wrap a WidgetClassHierarchyChangedFieldCallback into a C_WidgetClassHierarchyChangedFieldCallback.

WidgetClassKeyPressEventFieldCallback

type C_WidgetClassKeyPressEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt

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

type WidgetClassKeyPressEventFieldCallback = Widget -> EventKey -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassKeyPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyPressEventFieldCallback -> a -> EventKey -> m Bool

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

genClosure_WidgetClassKeyPressEventFieldCallback :: MonadIO m => WidgetClassKeyPressEventFieldCallback -> m (GClosure C_WidgetClassKeyPressEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassKeyPressEventFieldCallback :: C_WidgetClassKeyPressEventFieldCallback -> IO (FunPtr C_WidgetClassKeyPressEventFieldCallback)

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

noWidgetClassKeyPressEventFieldCallback :: Maybe WidgetClassKeyPressEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassKeyPressEventFieldCallback.

wrap_WidgetClassKeyPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)) -> WidgetClassKeyPressEventFieldCallback -> C_WidgetClassKeyPressEventFieldCallback

Wrap a WidgetClassKeyPressEventFieldCallback into a C_WidgetClassKeyPressEventFieldCallback.

WidgetClassKeyReleaseEventFieldCallback

type C_WidgetClassKeyReleaseEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt

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

type WidgetClassKeyReleaseEventFieldCallback = Widget -> EventKey -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassKeyReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyReleaseEventFieldCallback -> a -> EventKey -> m Bool

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

genClosure_WidgetClassKeyReleaseEventFieldCallback :: MonadIO m => WidgetClassKeyReleaseEventFieldCallback -> m (GClosure C_WidgetClassKeyReleaseEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassKeyReleaseEventFieldCallback :: C_WidgetClassKeyReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)

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

noWidgetClassKeyReleaseEventFieldCallback :: Maybe WidgetClassKeyReleaseEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassKeyReleaseEventFieldCallback.

wrap_WidgetClassKeyReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)) -> WidgetClassKeyReleaseEventFieldCallback -> C_WidgetClassKeyReleaseEventFieldCallback

Wrap a WidgetClassKeyReleaseEventFieldCallback into a C_WidgetClassKeyReleaseEventFieldCallback.

WidgetClassKeynavFailedFieldCallback

type C_WidgetClassKeynavFailedFieldCallback = Ptr Widget -> CUInt -> IO CInt

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

type WidgetClassKeynavFailedFieldCallback

Arguments

 = Widget

widget: a Widget

-> DirectionType

direction: direction of focus movement

-> IO Bool

Returns: True if stopping keyboard navigation is fine, False if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).

No description available in the introspection data.

dynamic_WidgetClassKeynavFailedFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassKeynavFailedFieldCallback

-> a

widget: a Widget

-> DirectionType

direction: direction of focus movement

-> m Bool

Returns: True if stopping keyboard navigation is fine, False if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).

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

genClosure_WidgetClassKeynavFailedFieldCallback :: MonadIO m => WidgetClassKeynavFailedFieldCallback -> m (GClosure C_WidgetClassKeynavFailedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassKeynavFailedFieldCallback :: C_WidgetClassKeynavFailedFieldCallback -> IO (FunPtr C_WidgetClassKeynavFailedFieldCallback)

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

noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassKeynavFailedFieldCallback.

wrap_WidgetClassKeynavFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeynavFailedFieldCallback)) -> WidgetClassKeynavFailedFieldCallback -> C_WidgetClassKeynavFailedFieldCallback

Wrap a WidgetClassKeynavFailedFieldCallback into a C_WidgetClassKeynavFailedFieldCallback.

WidgetClassLeaveNotifyEventFieldCallback

type C_WidgetClassLeaveNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt

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

type WidgetClassLeaveNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassLeaveNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassLeaveNotifyEventFieldCallback -> a -> EventCrossing -> m Bool

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

genClosure_WidgetClassLeaveNotifyEventFieldCallback :: MonadIO m => WidgetClassLeaveNotifyEventFieldCallback -> m (GClosure C_WidgetClassLeaveNotifyEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassLeaveNotifyEventFieldCallback :: C_WidgetClassLeaveNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)

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

noWidgetClassLeaveNotifyEventFieldCallback :: Maybe WidgetClassLeaveNotifyEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassLeaveNotifyEventFieldCallback.

wrap_WidgetClassLeaveNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)) -> WidgetClassLeaveNotifyEventFieldCallback -> C_WidgetClassLeaveNotifyEventFieldCallback

Wrap a WidgetClassLeaveNotifyEventFieldCallback into a C_WidgetClassLeaveNotifyEventFieldCallback.

WidgetClassMapEventFieldCallback

type C_WidgetClassMapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

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

type WidgetClassMapEventFieldCallback = Widget -> EventAny -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassMapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapEventFieldCallback -> a -> EventAny -> m Bool

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

genClosure_WidgetClassMapEventFieldCallback :: MonadIO m => WidgetClassMapEventFieldCallback -> m (GClosure C_WidgetClassMapEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassMapEventFieldCallback :: C_WidgetClassMapEventFieldCallback -> IO (FunPtr C_WidgetClassMapEventFieldCallback)

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

noWidgetClassMapEventFieldCallback :: Maybe WidgetClassMapEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassMapEventFieldCallback.

wrap_WidgetClassMapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapEventFieldCallback)) -> WidgetClassMapEventFieldCallback -> C_WidgetClassMapEventFieldCallback

Wrap a WidgetClassMapEventFieldCallback into a C_WidgetClassMapEventFieldCallback.

WidgetClassMapFieldCallback

type C_WidgetClassMapFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassMapFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassMapFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassMapFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassMapFieldCallback :: MonadIO m => WidgetClassMapFieldCallback -> m (GClosure C_WidgetClassMapFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassMapFieldCallback :: C_WidgetClassMapFieldCallback -> IO (FunPtr C_WidgetClassMapFieldCallback)

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

noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassMapFieldCallback.

wrap_WidgetClassMapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapFieldCallback)) -> WidgetClassMapFieldCallback -> C_WidgetClassMapFieldCallback

Wrap a WidgetClassMapFieldCallback into a C_WidgetClassMapFieldCallback.

WidgetClassMnemonicActivateFieldCallback

type C_WidgetClassMnemonicActivateFieldCallback = Ptr Widget -> CInt -> IO CInt

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

type WidgetClassMnemonicActivateFieldCallback

Arguments

 = Widget

widget: a Widget

-> Bool

groupCycling: True if there are other widgets with the same mnemonic

-> IO Bool

Returns: True if the signal has been handled

No description available in the introspection data.

dynamic_WidgetClassMnemonicActivateFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassMnemonicActivateFieldCallback

-> a

widget: a Widget

-> Bool

groupCycling: True if there are other widgets with the same mnemonic

-> m Bool

Returns: True if the signal has been handled

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

genClosure_WidgetClassMnemonicActivateFieldCallback :: MonadIO m => WidgetClassMnemonicActivateFieldCallback -> m (GClosure C_WidgetClassMnemonicActivateFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassMnemonicActivateFieldCallback :: C_WidgetClassMnemonicActivateFieldCallback -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)

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

noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassMnemonicActivateFieldCallback.

wrap_WidgetClassMnemonicActivateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)) -> WidgetClassMnemonicActivateFieldCallback -> C_WidgetClassMnemonicActivateFieldCallback

Wrap a WidgetClassMnemonicActivateFieldCallback into a C_WidgetClassMnemonicActivateFieldCallback.

WidgetClassMotionNotifyEventFieldCallback

type C_WidgetClassMotionNotifyEventFieldCallback = Ptr Widget -> Ptr EventMotion -> IO CInt

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

type WidgetClassMotionNotifyEventFieldCallback = Widget -> EventMotion -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassMotionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> a -> EventMotion -> m Bool

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

genClosure_WidgetClassMotionNotifyEventFieldCallback :: MonadIO m => WidgetClassMotionNotifyEventFieldCallback -> m (GClosure C_WidgetClassMotionNotifyEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassMotionNotifyEventFieldCallback :: C_WidgetClassMotionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)

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

noWidgetClassMotionNotifyEventFieldCallback :: Maybe WidgetClassMotionNotifyEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassMotionNotifyEventFieldCallback.

wrap_WidgetClassMotionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)) -> WidgetClassMotionNotifyEventFieldCallback -> C_WidgetClassMotionNotifyEventFieldCallback

Wrap a WidgetClassMotionNotifyEventFieldCallback into a C_WidgetClassMotionNotifyEventFieldCallback.

WidgetClassMoveFocusFieldCallback

type C_WidgetClassMoveFocusFieldCallback = Ptr Widget -> CUInt -> IO ()

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

type WidgetClassMoveFocusFieldCallback = Widget -> DirectionType -> IO ()

No description available in the introspection data.

dynamic_WidgetClassMoveFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMoveFocusFieldCallback -> a -> DirectionType -> m ()

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

genClosure_WidgetClassMoveFocusFieldCallback :: MonadIO m => WidgetClassMoveFocusFieldCallback -> m (GClosure C_WidgetClassMoveFocusFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassMoveFocusFieldCallback :: C_WidgetClassMoveFocusFieldCallback -> IO (FunPtr C_WidgetClassMoveFocusFieldCallback)

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

noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassMoveFocusFieldCallback.

wrap_WidgetClassMoveFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMoveFocusFieldCallback)) -> WidgetClassMoveFocusFieldCallback -> C_WidgetClassMoveFocusFieldCallback

Wrap a WidgetClassMoveFocusFieldCallback into a C_WidgetClassMoveFocusFieldCallback.

WidgetClassParentSetFieldCallback

type C_WidgetClassParentSetFieldCallback = Ptr Widget -> Ptr Widget -> IO ()

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

type WidgetClassParentSetFieldCallback = Widget -> Widget -> IO ()

No description available in the introspection data.

dynamic_WidgetClassParentSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassParentSetFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassParentSetFieldCallback :: MonadIO m => WidgetClassParentSetFieldCallback -> m (GClosure C_WidgetClassParentSetFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassParentSetFieldCallback :: C_WidgetClassParentSetFieldCallback -> IO (FunPtr C_WidgetClassParentSetFieldCallback)

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

noWidgetClassParentSetFieldCallback :: Maybe WidgetClassParentSetFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassParentSetFieldCallback.

wrap_WidgetClassParentSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassParentSetFieldCallback)) -> WidgetClassParentSetFieldCallback -> C_WidgetClassParentSetFieldCallback

Wrap a WidgetClassParentSetFieldCallback into a C_WidgetClassParentSetFieldCallback.

WidgetClassPopupMenuFieldCallback

type C_WidgetClassPopupMenuFieldCallback = Ptr Widget -> IO CInt

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

type WidgetClassPopupMenuFieldCallback = Widget -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassPopupMenuFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassPopupMenuFieldCallback -> a -> m Bool

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

genClosure_WidgetClassPopupMenuFieldCallback :: MonadIO m => WidgetClassPopupMenuFieldCallback -> m (GClosure C_WidgetClassPopupMenuFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassPopupMenuFieldCallback :: C_WidgetClassPopupMenuFieldCallback -> IO (FunPtr C_WidgetClassPopupMenuFieldCallback)

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

noWidgetClassPopupMenuFieldCallback :: Maybe WidgetClassPopupMenuFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassPopupMenuFieldCallback.

wrap_WidgetClassPopupMenuFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)) -> WidgetClassPopupMenuFieldCallback -> C_WidgetClassPopupMenuFieldCallback

Wrap a WidgetClassPopupMenuFieldCallback into a C_WidgetClassPopupMenuFieldCallback.

WidgetClassPropertyNotifyEventFieldCallback

type C_WidgetClassPropertyNotifyEventFieldCallback = Ptr Widget -> Ptr EventProperty -> IO CInt

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

type WidgetClassPropertyNotifyEventFieldCallback = Widget -> EventProperty -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassPropertyNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> a -> EventProperty -> m Bool

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

genClosure_WidgetClassPropertyNotifyEventFieldCallback :: MonadIO m => WidgetClassPropertyNotifyEventFieldCallback -> m (GClosure C_WidgetClassPropertyNotifyEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassPropertyNotifyEventFieldCallback :: C_WidgetClassPropertyNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)

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

noWidgetClassPropertyNotifyEventFieldCallback :: Maybe WidgetClassPropertyNotifyEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassPropertyNotifyEventFieldCallback.

wrap_WidgetClassPropertyNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)) -> WidgetClassPropertyNotifyEventFieldCallback -> C_WidgetClassPropertyNotifyEventFieldCallback

Wrap a WidgetClassPropertyNotifyEventFieldCallback into a C_WidgetClassPropertyNotifyEventFieldCallback.

WidgetClassProximityInEventFieldCallback

type C_WidgetClassProximityInEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt

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

type WidgetClassProximityInEventFieldCallback = Widget -> EventProximity -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassProximityInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityInEventFieldCallback -> a -> EventProximity -> m Bool

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

genClosure_WidgetClassProximityInEventFieldCallback :: MonadIO m => WidgetClassProximityInEventFieldCallback -> m (GClosure C_WidgetClassProximityInEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassProximityInEventFieldCallback :: C_WidgetClassProximityInEventFieldCallback -> IO (FunPtr C_WidgetClassProximityInEventFieldCallback)

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

noWidgetClassProximityInEventFieldCallback :: Maybe WidgetClassProximityInEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassProximityInEventFieldCallback.

wrap_WidgetClassProximityInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)) -> WidgetClassProximityInEventFieldCallback -> C_WidgetClassProximityInEventFieldCallback

Wrap a WidgetClassProximityInEventFieldCallback into a C_WidgetClassProximityInEventFieldCallback.

WidgetClassProximityOutEventFieldCallback

type C_WidgetClassProximityOutEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt

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

type WidgetClassProximityOutEventFieldCallback = Widget -> EventProximity -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassProximityOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityOutEventFieldCallback -> a -> EventProximity -> m Bool

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

genClosure_WidgetClassProximityOutEventFieldCallback :: MonadIO m => WidgetClassProximityOutEventFieldCallback -> m (GClosure C_WidgetClassProximityOutEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassProximityOutEventFieldCallback :: C_WidgetClassProximityOutEventFieldCallback -> IO (FunPtr C_WidgetClassProximityOutEventFieldCallback)

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

noWidgetClassProximityOutEventFieldCallback :: Maybe WidgetClassProximityOutEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassProximityOutEventFieldCallback.

wrap_WidgetClassProximityOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityOutEventFieldCallback)) -> WidgetClassProximityOutEventFieldCallback -> C_WidgetClassProximityOutEventFieldCallback

Wrap a WidgetClassProximityOutEventFieldCallback into a C_WidgetClassProximityOutEventFieldCallback.

WidgetClassQueryTooltipFieldCallback

type C_WidgetClassQueryTooltipFieldCallback = Ptr Widget -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> IO CInt

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

type WidgetClassQueryTooltipFieldCallback = Widget -> Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassQueryTooltipFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsTooltip b) => FunPtr C_WidgetClassQueryTooltipFieldCallback -> a -> Int32 -> Int32 -> Bool -> b -> m Bool

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

genClosure_WidgetClassQueryTooltipFieldCallback :: MonadIO m => WidgetClassQueryTooltipFieldCallback -> m (GClosure C_WidgetClassQueryTooltipFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassQueryTooltipFieldCallback :: C_WidgetClassQueryTooltipFieldCallback -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)

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

noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassQueryTooltipFieldCallback.

wrap_WidgetClassQueryTooltipFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)) -> WidgetClassQueryTooltipFieldCallback -> C_WidgetClassQueryTooltipFieldCallback

Wrap a WidgetClassQueryTooltipFieldCallback into a C_WidgetClassQueryTooltipFieldCallback.

WidgetClassQueueDrawRegionFieldCallback

type C_WidgetClassQueueDrawRegionFieldCallback = Ptr Widget -> Ptr Region -> IO ()

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

type WidgetClassQueueDrawRegionFieldCallback

Arguments

 = Widget

widget: a Widget

-> Region

region: region to draw

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassQueueDrawRegionFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassQueueDrawRegionFieldCallback

-> a

widget: a Widget

-> Region

region: region to draw

-> m ()

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

genClosure_WidgetClassQueueDrawRegionFieldCallback :: MonadIO m => WidgetClassQueueDrawRegionFieldCallback -> m (GClosure C_WidgetClassQueueDrawRegionFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassQueueDrawRegionFieldCallback :: C_WidgetClassQueueDrawRegionFieldCallback -> IO (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)

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

noWidgetClassQueueDrawRegionFieldCallback :: Maybe WidgetClassQueueDrawRegionFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassQueueDrawRegionFieldCallback.

wrap_WidgetClassQueueDrawRegionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)) -> WidgetClassQueueDrawRegionFieldCallback -> C_WidgetClassQueueDrawRegionFieldCallback

Wrap a WidgetClassQueueDrawRegionFieldCallback into a C_WidgetClassQueueDrawRegionFieldCallback.

WidgetClassRealizeFieldCallback

type C_WidgetClassRealizeFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassRealizeFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassRealizeFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassRealizeFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassRealizeFieldCallback :: MonadIO m => WidgetClassRealizeFieldCallback -> m (GClosure C_WidgetClassRealizeFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassRealizeFieldCallback :: C_WidgetClassRealizeFieldCallback -> IO (FunPtr C_WidgetClassRealizeFieldCallback)

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

noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassRealizeFieldCallback.

wrap_WidgetClassRealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRealizeFieldCallback)) -> WidgetClassRealizeFieldCallback -> C_WidgetClassRealizeFieldCallback

Wrap a WidgetClassRealizeFieldCallback into a C_WidgetClassRealizeFieldCallback.

WidgetClassScreenChangedFieldCallback

type C_WidgetClassScreenChangedFieldCallback = Ptr Widget -> Ptr Screen -> IO ()

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

type WidgetClassScreenChangedFieldCallback = Widget -> Screen -> IO ()

No description available in the introspection data.

dynamic_WidgetClassScreenChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsScreen b) => FunPtr C_WidgetClassScreenChangedFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassScreenChangedFieldCallback :: MonadIO m => WidgetClassScreenChangedFieldCallback -> m (GClosure C_WidgetClassScreenChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassScreenChangedFieldCallback :: C_WidgetClassScreenChangedFieldCallback -> IO (FunPtr C_WidgetClassScreenChangedFieldCallback)

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

noWidgetClassScreenChangedFieldCallback :: Maybe WidgetClassScreenChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassScreenChangedFieldCallback.

wrap_WidgetClassScreenChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)) -> WidgetClassScreenChangedFieldCallback -> C_WidgetClassScreenChangedFieldCallback

Wrap a WidgetClassScreenChangedFieldCallback into a C_WidgetClassScreenChangedFieldCallback.

WidgetClassScrollEventFieldCallback

type C_WidgetClassScrollEventFieldCallback = Ptr Widget -> Ptr EventScroll -> IO CInt

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

type WidgetClassScrollEventFieldCallback = Widget -> EventScroll -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassScrollEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassScrollEventFieldCallback -> a -> EventScroll -> m Bool

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

genClosure_WidgetClassScrollEventFieldCallback :: MonadIO m => WidgetClassScrollEventFieldCallback -> m (GClosure C_WidgetClassScrollEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassScrollEventFieldCallback :: C_WidgetClassScrollEventFieldCallback -> IO (FunPtr C_WidgetClassScrollEventFieldCallback)

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

noWidgetClassScrollEventFieldCallback :: Maybe WidgetClassScrollEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassScrollEventFieldCallback.

wrap_WidgetClassScrollEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScrollEventFieldCallback)) -> WidgetClassScrollEventFieldCallback -> C_WidgetClassScrollEventFieldCallback

Wrap a WidgetClassScrollEventFieldCallback into a C_WidgetClassScrollEventFieldCallback.

WidgetClassSelectionClearEventFieldCallback

type C_WidgetClassSelectionClearEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt

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

type WidgetClassSelectionClearEventFieldCallback = Widget -> EventSelection -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassSelectionClearEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionClearEventFieldCallback -> a -> EventSelection -> m Bool

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

genClosure_WidgetClassSelectionClearEventFieldCallback :: MonadIO m => WidgetClassSelectionClearEventFieldCallback -> m (GClosure C_WidgetClassSelectionClearEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSelectionClearEventFieldCallback :: C_WidgetClassSelectionClearEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionClearEventFieldCallback)

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

noWidgetClassSelectionClearEventFieldCallback :: Maybe WidgetClassSelectionClearEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSelectionClearEventFieldCallback.

wrap_WidgetClassSelectionClearEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)) -> WidgetClassSelectionClearEventFieldCallback -> C_WidgetClassSelectionClearEventFieldCallback

Wrap a WidgetClassSelectionClearEventFieldCallback into a C_WidgetClassSelectionClearEventFieldCallback.

WidgetClassSelectionGetFieldCallback

type C_WidgetClassSelectionGetFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> Word32 -> IO ()

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

type WidgetClassSelectionGetFieldCallback = Widget -> SelectionData -> Word32 -> Word32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassSelectionGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionGetFieldCallback -> a -> SelectionData -> Word32 -> Word32 -> m ()

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

genClosure_WidgetClassSelectionGetFieldCallback :: MonadIO m => WidgetClassSelectionGetFieldCallback -> m (GClosure C_WidgetClassSelectionGetFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSelectionGetFieldCallback :: C_WidgetClassSelectionGetFieldCallback -> IO (FunPtr C_WidgetClassSelectionGetFieldCallback)

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

noWidgetClassSelectionGetFieldCallback :: Maybe WidgetClassSelectionGetFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSelectionGetFieldCallback.

wrap_WidgetClassSelectionGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionGetFieldCallback)) -> WidgetClassSelectionGetFieldCallback -> C_WidgetClassSelectionGetFieldCallback

Wrap a WidgetClassSelectionGetFieldCallback into a C_WidgetClassSelectionGetFieldCallback.

WidgetClassSelectionNotifyEventFieldCallback

type C_WidgetClassSelectionNotifyEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt

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

type WidgetClassSelectionNotifyEventFieldCallback = Widget -> EventSelection -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassSelectionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionNotifyEventFieldCallback -> a -> EventSelection -> m Bool

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

genClosure_WidgetClassSelectionNotifyEventFieldCallback :: MonadIO m => WidgetClassSelectionNotifyEventFieldCallback -> m (GClosure C_WidgetClassSelectionNotifyEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSelectionNotifyEventFieldCallback :: C_WidgetClassSelectionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)

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

noWidgetClassSelectionNotifyEventFieldCallback :: Maybe WidgetClassSelectionNotifyEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSelectionNotifyEventFieldCallback.

wrap_WidgetClassSelectionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)) -> WidgetClassSelectionNotifyEventFieldCallback -> C_WidgetClassSelectionNotifyEventFieldCallback

Wrap a WidgetClassSelectionNotifyEventFieldCallback into a C_WidgetClassSelectionNotifyEventFieldCallback.

WidgetClassSelectionReceivedFieldCallback

type C_WidgetClassSelectionReceivedFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> IO ()

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

type WidgetClassSelectionReceivedFieldCallback = Widget -> SelectionData -> Word32 -> IO ()

No description available in the introspection data.

dynamic_WidgetClassSelectionReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionReceivedFieldCallback -> a -> SelectionData -> Word32 -> m ()

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

genClosure_WidgetClassSelectionReceivedFieldCallback :: MonadIO m => WidgetClassSelectionReceivedFieldCallback -> m (GClosure C_WidgetClassSelectionReceivedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSelectionReceivedFieldCallback :: C_WidgetClassSelectionReceivedFieldCallback -> IO (FunPtr C_WidgetClassSelectionReceivedFieldCallback)

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

noWidgetClassSelectionReceivedFieldCallback :: Maybe WidgetClassSelectionReceivedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSelectionReceivedFieldCallback.

wrap_WidgetClassSelectionReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionReceivedFieldCallback)) -> WidgetClassSelectionReceivedFieldCallback -> C_WidgetClassSelectionReceivedFieldCallback

Wrap a WidgetClassSelectionReceivedFieldCallback into a C_WidgetClassSelectionReceivedFieldCallback.

WidgetClassSelectionRequestEventFieldCallback

type C_WidgetClassSelectionRequestEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt

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

type WidgetClassSelectionRequestEventFieldCallback = Widget -> EventSelection -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassSelectionRequestEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionRequestEventFieldCallback -> a -> EventSelection -> m Bool

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

genClosure_WidgetClassSelectionRequestEventFieldCallback :: MonadIO m => WidgetClassSelectionRequestEventFieldCallback -> m (GClosure C_WidgetClassSelectionRequestEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSelectionRequestEventFieldCallback :: C_WidgetClassSelectionRequestEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)

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

noWidgetClassSelectionRequestEventFieldCallback :: Maybe WidgetClassSelectionRequestEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSelectionRequestEventFieldCallback.

wrap_WidgetClassSelectionRequestEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)) -> WidgetClassSelectionRequestEventFieldCallback -> C_WidgetClassSelectionRequestEventFieldCallback

Wrap a WidgetClassSelectionRequestEventFieldCallback into a C_WidgetClassSelectionRequestEventFieldCallback.

WidgetClassShowAllFieldCallback

type C_WidgetClassShowAllFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassShowAllFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassShowAllFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassShowAllFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassShowAllFieldCallback :: MonadIO m => WidgetClassShowAllFieldCallback -> m (GClosure C_WidgetClassShowAllFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassShowAllFieldCallback :: C_WidgetClassShowAllFieldCallback -> IO (FunPtr C_WidgetClassShowAllFieldCallback)

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

noWidgetClassShowAllFieldCallback :: Maybe WidgetClassShowAllFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassShowAllFieldCallback.

wrap_WidgetClassShowAllFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowAllFieldCallback)) -> WidgetClassShowAllFieldCallback -> C_WidgetClassShowAllFieldCallback

Wrap a WidgetClassShowAllFieldCallback into a C_WidgetClassShowAllFieldCallback.

WidgetClassShowFieldCallback

type C_WidgetClassShowFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassShowFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassShowFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassShowFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassShowFieldCallback :: MonadIO m => WidgetClassShowFieldCallback -> m (GClosure C_WidgetClassShowFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassShowFieldCallback :: C_WidgetClassShowFieldCallback -> IO (FunPtr C_WidgetClassShowFieldCallback)

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

noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassShowFieldCallback.

wrap_WidgetClassShowFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowFieldCallback)) -> WidgetClassShowFieldCallback -> C_WidgetClassShowFieldCallback

Wrap a WidgetClassShowFieldCallback into a C_WidgetClassShowFieldCallback.

WidgetClassShowHelpFieldCallback

type C_WidgetClassShowHelpFieldCallback = Ptr Widget -> CUInt -> IO CInt

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

type WidgetClassShowHelpFieldCallback = Widget -> WidgetHelpType -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassShowHelpFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowHelpFieldCallback -> a -> WidgetHelpType -> m Bool

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

genClosure_WidgetClassShowHelpFieldCallback :: MonadIO m => WidgetClassShowHelpFieldCallback -> m (GClosure C_WidgetClassShowHelpFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassShowHelpFieldCallback :: C_WidgetClassShowHelpFieldCallback -> IO (FunPtr C_WidgetClassShowHelpFieldCallback)

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

noWidgetClassShowHelpFieldCallback :: Maybe WidgetClassShowHelpFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassShowHelpFieldCallback.

wrap_WidgetClassShowHelpFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowHelpFieldCallback)) -> WidgetClassShowHelpFieldCallback -> C_WidgetClassShowHelpFieldCallback

Wrap a WidgetClassShowHelpFieldCallback into a C_WidgetClassShowHelpFieldCallback.

WidgetClassSizeAllocateFieldCallback

type C_WidgetClassSizeAllocateFieldCallback = Ptr Widget -> Ptr Rectangle -> IO ()

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

type WidgetClassSizeAllocateFieldCallback

Arguments

 = Widget

widget: a Widget

-> Rectangle

allocation: position and size to be allocated to widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassSizeAllocateFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassSizeAllocateFieldCallback

-> a

widget: a Widget

-> Rectangle

allocation: position and size to be allocated to widget

-> m ()

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

genClosure_WidgetClassSizeAllocateFieldCallback :: MonadIO m => WidgetClassSizeAllocateFieldCallback -> m (GClosure C_WidgetClassSizeAllocateFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSizeAllocateFieldCallback :: C_WidgetClassSizeAllocateFieldCallback -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)

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

noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSizeAllocateFieldCallback.

wrap_WidgetClassSizeAllocateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)) -> WidgetClassSizeAllocateFieldCallback -> C_WidgetClassSizeAllocateFieldCallback

Wrap a WidgetClassSizeAllocateFieldCallback into a C_WidgetClassSizeAllocateFieldCallback.

WidgetClassStateChangedFieldCallback

type C_WidgetClassStateChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

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

type WidgetClassStateChangedFieldCallback = Widget -> StateType -> IO ()

No description available in the introspection data.

dynamic_WidgetClassStateChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateChangedFieldCallback -> a -> StateType -> m ()

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

genClosure_WidgetClassStateChangedFieldCallback :: MonadIO m => WidgetClassStateChangedFieldCallback -> m (GClosure C_WidgetClassStateChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassStateChangedFieldCallback :: C_WidgetClassStateChangedFieldCallback -> IO (FunPtr C_WidgetClassStateChangedFieldCallback)

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

noWidgetClassStateChangedFieldCallback :: Maybe WidgetClassStateChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassStateChangedFieldCallback.

wrap_WidgetClassStateChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)) -> WidgetClassStateChangedFieldCallback -> C_WidgetClassStateChangedFieldCallback

Wrap a WidgetClassStateChangedFieldCallback into a C_WidgetClassStateChangedFieldCallback.

WidgetClassStateFlagsChangedFieldCallback

type C_WidgetClassStateFlagsChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

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

type WidgetClassStateFlagsChangedFieldCallback = Widget -> [StateFlags] -> IO ()

No description available in the introspection data.

dynamic_WidgetClassStateFlagsChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> a -> [StateFlags] -> m ()

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

genClosure_WidgetClassStateFlagsChangedFieldCallback :: MonadIO m => WidgetClassStateFlagsChangedFieldCallback -> m (GClosure C_WidgetClassStateFlagsChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassStateFlagsChangedFieldCallback :: C_WidgetClassStateFlagsChangedFieldCallback -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)

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

noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassStateFlagsChangedFieldCallback.

wrap_WidgetClassStateFlagsChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)) -> WidgetClassStateFlagsChangedFieldCallback -> C_WidgetClassStateFlagsChangedFieldCallback

Wrap a WidgetClassStateFlagsChangedFieldCallback into a C_WidgetClassStateFlagsChangedFieldCallback.

WidgetClassStyleSetFieldCallback

type C_WidgetClassStyleSetFieldCallback = Ptr Widget -> Ptr Style -> IO ()

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

type WidgetClassStyleSetFieldCallback = Widget -> Style -> IO ()

No description available in the introspection data.

dynamic_WidgetClassStyleSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsStyle b) => FunPtr C_WidgetClassStyleSetFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassStyleSetFieldCallback :: MonadIO m => WidgetClassStyleSetFieldCallback -> m (GClosure C_WidgetClassStyleSetFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassStyleSetFieldCallback :: C_WidgetClassStyleSetFieldCallback -> IO (FunPtr C_WidgetClassStyleSetFieldCallback)

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

noWidgetClassStyleSetFieldCallback :: Maybe WidgetClassStyleSetFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassStyleSetFieldCallback.

wrap_WidgetClassStyleSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleSetFieldCallback)) -> WidgetClassStyleSetFieldCallback -> C_WidgetClassStyleSetFieldCallback

Wrap a WidgetClassStyleSetFieldCallback into a C_WidgetClassStyleSetFieldCallback.

WidgetClassStyleUpdatedFieldCallback

type C_WidgetClassStyleUpdatedFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassStyleUpdatedFieldCallback = Widget -> IO ()

No description available in the introspection data.

dynamic_WidgetClassStyleUpdatedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStyleUpdatedFieldCallback -> a -> m ()

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

genClosure_WidgetClassStyleUpdatedFieldCallback :: MonadIO m => WidgetClassStyleUpdatedFieldCallback -> m (GClosure C_WidgetClassStyleUpdatedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassStyleUpdatedFieldCallback :: C_WidgetClassStyleUpdatedFieldCallback -> IO (FunPtr C_WidgetClassStyleUpdatedFieldCallback)

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

noWidgetClassStyleUpdatedFieldCallback :: Maybe WidgetClassStyleUpdatedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassStyleUpdatedFieldCallback.

wrap_WidgetClassStyleUpdatedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleUpdatedFieldCallback)) -> WidgetClassStyleUpdatedFieldCallback -> C_WidgetClassStyleUpdatedFieldCallback

Wrap a WidgetClassStyleUpdatedFieldCallback into a C_WidgetClassStyleUpdatedFieldCallback.

WidgetClassTouchEventFieldCallback

type C_WidgetClassTouchEventFieldCallback = Ptr Widget -> Ptr EventTouch -> IO CInt

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

type WidgetClassTouchEventFieldCallback = Widget -> EventTouch -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassTouchEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassTouchEventFieldCallback -> a -> EventTouch -> m Bool

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

genClosure_WidgetClassTouchEventFieldCallback :: MonadIO m => WidgetClassTouchEventFieldCallback -> m (GClosure C_WidgetClassTouchEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassTouchEventFieldCallback :: C_WidgetClassTouchEventFieldCallback -> IO (FunPtr C_WidgetClassTouchEventFieldCallback)

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

noWidgetClassTouchEventFieldCallback :: Maybe WidgetClassTouchEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassTouchEventFieldCallback.

wrap_WidgetClassTouchEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassTouchEventFieldCallback)) -> WidgetClassTouchEventFieldCallback -> C_WidgetClassTouchEventFieldCallback

Wrap a WidgetClassTouchEventFieldCallback into a C_WidgetClassTouchEventFieldCallback.

WidgetClassUnmapEventFieldCallback

type C_WidgetClassUnmapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

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

type WidgetClassUnmapEventFieldCallback = Widget -> EventAny -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassUnmapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapEventFieldCallback -> a -> EventAny -> m Bool

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

genClosure_WidgetClassUnmapEventFieldCallback :: MonadIO m => WidgetClassUnmapEventFieldCallback -> m (GClosure C_WidgetClassUnmapEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassUnmapEventFieldCallback :: C_WidgetClassUnmapEventFieldCallback -> IO (FunPtr C_WidgetClassUnmapEventFieldCallback)

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

noWidgetClassUnmapEventFieldCallback :: Maybe WidgetClassUnmapEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassUnmapEventFieldCallback.

wrap_WidgetClassUnmapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapEventFieldCallback)) -> WidgetClassUnmapEventFieldCallback -> C_WidgetClassUnmapEventFieldCallback

Wrap a WidgetClassUnmapEventFieldCallback into a C_WidgetClassUnmapEventFieldCallback.

WidgetClassUnmapFieldCallback

type C_WidgetClassUnmapFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassUnmapFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassUnmapFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassUnmapFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassUnmapFieldCallback :: MonadIO m => WidgetClassUnmapFieldCallback -> m (GClosure C_WidgetClassUnmapFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassUnmapFieldCallback :: C_WidgetClassUnmapFieldCallback -> IO (FunPtr C_WidgetClassUnmapFieldCallback)

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

noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassUnmapFieldCallback.

wrap_WidgetClassUnmapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapFieldCallback)) -> WidgetClassUnmapFieldCallback -> C_WidgetClassUnmapFieldCallback

Wrap a WidgetClassUnmapFieldCallback into a C_WidgetClassUnmapFieldCallback.

WidgetClassUnrealizeFieldCallback

type C_WidgetClassUnrealizeFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassUnrealizeFieldCallback

Arguments

 = Widget

widget: a Widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassUnrealizeFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassUnrealizeFieldCallback

-> a

widget: a Widget

-> m ()

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

genClosure_WidgetClassUnrealizeFieldCallback :: MonadIO m => WidgetClassUnrealizeFieldCallback -> m (GClosure C_WidgetClassUnrealizeFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassUnrealizeFieldCallback :: C_WidgetClassUnrealizeFieldCallback -> IO (FunPtr C_WidgetClassUnrealizeFieldCallback)

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

noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassUnrealizeFieldCallback.

wrap_WidgetClassUnrealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrealizeFieldCallback)) -> WidgetClassUnrealizeFieldCallback -> C_WidgetClassUnrealizeFieldCallback

Wrap a WidgetClassUnrealizeFieldCallback into a C_WidgetClassUnrealizeFieldCallback.

WidgetClassVisibilityNotifyEventFieldCallback

type C_WidgetClassVisibilityNotifyEventFieldCallback = Ptr Widget -> Ptr EventVisibility -> IO CInt

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

type WidgetClassVisibilityNotifyEventFieldCallback = Widget -> EventVisibility -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassVisibilityNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> a -> EventVisibility -> m Bool

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

genClosure_WidgetClassVisibilityNotifyEventFieldCallback :: MonadIO m => WidgetClassVisibilityNotifyEventFieldCallback -> m (GClosure C_WidgetClassVisibilityNotifyEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassVisibilityNotifyEventFieldCallback :: C_WidgetClassVisibilityNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)

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

noWidgetClassVisibilityNotifyEventFieldCallback :: Maybe WidgetClassVisibilityNotifyEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassVisibilityNotifyEventFieldCallback.

wrap_WidgetClassVisibilityNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)) -> WidgetClassVisibilityNotifyEventFieldCallback -> C_WidgetClassVisibilityNotifyEventFieldCallback

Wrap a WidgetClassVisibilityNotifyEventFieldCallback into a C_WidgetClassVisibilityNotifyEventFieldCallback.

WidgetClassWindowStateEventFieldCallback

type C_WidgetClassWindowStateEventFieldCallback = Ptr Widget -> Ptr EventWindowState -> IO CInt

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

type WidgetClassWindowStateEventFieldCallback = Widget -> EventWindowState -> IO Bool

No description available in the introspection data.

dynamic_WidgetClassWindowStateEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassWindowStateEventFieldCallback -> a -> EventWindowState -> m Bool

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

genClosure_WidgetClassWindowStateEventFieldCallback :: MonadIO m => WidgetClassWindowStateEventFieldCallback -> m (GClosure C_WidgetClassWindowStateEventFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassWindowStateEventFieldCallback :: C_WidgetClassWindowStateEventFieldCallback -> IO (FunPtr C_WidgetClassWindowStateEventFieldCallback)

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

noWidgetClassWindowStateEventFieldCallback :: Maybe WidgetClassWindowStateEventFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassWindowStateEventFieldCallback.

wrap_WidgetClassWindowStateEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassWindowStateEventFieldCallback)) -> WidgetClassWindowStateEventFieldCallback -> C_WidgetClassWindowStateEventFieldCallback

Wrap a WidgetClassWindowStateEventFieldCallback into a C_WidgetClassWindowStateEventFieldCallback.