GI.Gtk.Callbacks

Signals

AssistantPageFunc

type AssistantPageFunc

Arguments

 = Int32

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

-> IO Int32

Returns: The next page number

Type of callback used to calculate the next page in a GtkAssistant.

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.

See assistantSetForwardPageFunc.

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

Type of callback used to calculate the next page in a GtkAssistant.

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.

See assistantSetForwardPageFunc.

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.

BuildableParserEndElementFieldCallback

type BuildableParserEndElementFieldCallback

Arguments

 = BuildableParseContext

-> Text

-> IO ()

(Can throw GError)

No description available in the introspection data.

type BuildableParserEndElementFieldCallback_WithClosures

Arguments

 = BuildableParseContext

-> Text

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

type C_BuildableParserEndElementFieldCallback = Ptr BuildableParseContext -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

drop_closures_BuildableParserEndElementFieldCallback :: BuildableParserEndElementFieldCallback -> BuildableParserEndElementFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BuildableParserEndElementFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BuildableParserEndElementFieldCallback

-> BuildableParseContext

-> Text

-> Ptr ()

-> m ()

(Can throw GError)

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

mk_BuildableParserEndElementFieldCallback :: C_BuildableParserEndElementFieldCallback -> IO (FunPtr C_BuildableParserEndElementFieldCallback)

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

noBuildableParserEndElementFieldCallback :: Maybe BuildableParserEndElementFieldCallback

A convenience synonym for Nothing :: Maybe BuildableParserEndElementFieldCallback.

noBuildableParserEndElementFieldCallback_WithClosures :: Maybe BuildableParserEndElementFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe BuildableParserEndElementFieldCallback_WithClosures.

BuildableParserErrorFieldCallback

type BuildableParserErrorFieldCallback = BuildableParseContext -> GError -> IO ()

No description available in the introspection data.

type BuildableParserErrorFieldCallback_WithClosures = BuildableParseContext -> GError -> Ptr () -> IO ()

No description available in the introspection data.

type C_BuildableParserErrorFieldCallback = Ptr BuildableParseContext -> Ptr GError -> Ptr () -> IO ()

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

drop_closures_BuildableParserErrorFieldCallback :: BuildableParserErrorFieldCallback -> BuildableParserErrorFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BuildableParserErrorFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserErrorFieldCallback -> BuildableParseContext -> GError -> Ptr () -> m ()

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

genClosure_BuildableParserErrorFieldCallback :: MonadIO m => BuildableParserErrorFieldCallback -> m (GClosure C_BuildableParserErrorFieldCallback)

Wrap the callback into a GClosure.

mk_BuildableParserErrorFieldCallback :: C_BuildableParserErrorFieldCallback -> IO (FunPtr C_BuildableParserErrorFieldCallback)

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

noBuildableParserErrorFieldCallback :: Maybe BuildableParserErrorFieldCallback

A convenience synonym for Nothing :: Maybe BuildableParserErrorFieldCallback.

noBuildableParserErrorFieldCallback_WithClosures :: Maybe BuildableParserErrorFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe BuildableParserErrorFieldCallback_WithClosures.

wrap_BuildableParserErrorFieldCallback :: Maybe (Ptr (FunPtr C_BuildableParserErrorFieldCallback)) -> BuildableParserErrorFieldCallback_WithClosures -> C_BuildableParserErrorFieldCallback

Wrap a BuildableParserErrorFieldCallback into a C_BuildableParserErrorFieldCallback.

BuildableParserStartElementFieldCallback

type BuildableParserStartElementFieldCallback

Arguments

 = BuildableParseContext

-> Text

-> Text

-> Text

-> IO ()

(Can throw GError)

No description available in the introspection data.

type BuildableParserStartElementFieldCallback_WithClosures

Arguments

 = BuildableParseContext

-> Text

-> Text

-> Text

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

type C_BuildableParserStartElementFieldCallback = Ptr BuildableParseContext -> CString -> CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

drop_closures_BuildableParserStartElementFieldCallback :: BuildableParserStartElementFieldCallback -> BuildableParserStartElementFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BuildableParserStartElementFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BuildableParserStartElementFieldCallback

-> BuildableParseContext

-> Text

-> Text

-> Text

-> Ptr ()

-> m ()

(Can throw GError)

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

mk_BuildableParserStartElementFieldCallback :: C_BuildableParserStartElementFieldCallback -> IO (FunPtr C_BuildableParserStartElementFieldCallback)

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

noBuildableParserStartElementFieldCallback :: Maybe BuildableParserStartElementFieldCallback

A convenience synonym for Nothing :: Maybe BuildableParserStartElementFieldCallback.

noBuildableParserStartElementFieldCallback_WithClosures :: Maybe BuildableParserStartElementFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe BuildableParserStartElementFieldCallback_WithClosures.

BuildableParserTextFieldCallback

type BuildableParserTextFieldCallback

Arguments

 = BuildableParseContext

-> Text

-> Word64

-> IO ()

(Can throw GError)

No description available in the introspection data.

type BuildableParserTextFieldCallback_WithClosures

Arguments

 = BuildableParseContext

-> Text

-> Word64

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

type C_BuildableParserTextFieldCallback = Ptr BuildableParseContext -> CString -> Word64 -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

drop_closures_BuildableParserTextFieldCallback :: BuildableParserTextFieldCallback -> BuildableParserTextFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BuildableParserTextFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BuildableParserTextFieldCallback

-> BuildableParseContext

-> Text

-> Word64

-> Ptr ()

-> m ()

(Can throw GError)

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

mk_BuildableParserTextFieldCallback :: C_BuildableParserTextFieldCallback -> IO (FunPtr C_BuildableParserTextFieldCallback)

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

noBuildableParserTextFieldCallback :: Maybe BuildableParserTextFieldCallback

A convenience synonym for Nothing :: Maybe BuildableParserTextFieldCallback.

noBuildableParserTextFieldCallback_WithClosures :: Maybe BuildableParserTextFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe BuildableParserTextFieldCallback_WithClosures.

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 GtkCellArea, 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 GtkCellArea, 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 GtkCellArea, 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 GtkCellArea, 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 GtkCellLayout

-> CellRenderer

cell: the cell renderer whose value is to be set

-> TreeModel

treeModel: the model

-> TreeIter

iter: a GtkTreeIter 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 GtkCellLayout

-> CellRenderer

cell: the cell renderer whose value is to be set

-> TreeModel

treeModel: the model

-> TreeIter

iter: a GtkTreeIter 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 GtkCellLayout

-> b

cell: the cell renderer whose value is to be set

-> c

treeModel: the model

-> TreeIter

iter: a GtkTreeIter 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.

CustomAllocateFunc

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

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

type CustomAllocateFunc

Arguments

 = Widget

widget: the widget to allocate

-> Int32

width: the new width of the widget

-> Int32

height: the new height of the widget

-> Int32

baseline: the new baseline of the widget, or -1

-> IO ()

A function to be used by GtkCustomLayout to allocate a widget.

dynamic_CustomAllocateFunc

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_CustomAllocateFunc

-> a

widget: the widget to allocate

-> Int32

width: the new width of the widget

-> Int32

height: the new height of the widget

-> Int32

baseline: the new baseline of the widget, or -1

-> m ()

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

genClosure_CustomAllocateFunc :: MonadIO m => CustomAllocateFunc -> m (GClosure C_CustomAllocateFunc)

Wrap the callback into a GClosure.

mk_CustomAllocateFunc :: C_CustomAllocateFunc -> IO (FunPtr C_CustomAllocateFunc)

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

noCustomAllocateFunc :: Maybe CustomAllocateFunc

A convenience synonym for Nothing :: Maybe CustomAllocateFunc.

wrap_CustomAllocateFunc :: Maybe (Ptr (FunPtr C_CustomAllocateFunc)) -> CustomAllocateFunc -> C_CustomAllocateFunc

Wrap a CustomAllocateFunc into a C_CustomAllocateFunc.

CustomFilterFunc

type C_CustomFilterFunc = Ptr Object -> Ptr () -> IO CInt

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

type CustomFilterFunc

Arguments

 = Object

item: The item to be matched

-> IO Bool

Returns: True to keep the item around

User function that is called to determine if the item should be matched.

If the filter matches the item, this function must return True. If the item should be filtered out, False must be returned.

type CustomFilterFunc_WithClosures

Arguments

 = Object

item: The item to be matched

-> Ptr ()

userData: user data

-> IO Bool

Returns: True to keep the item around

User function that is called to determine if the item should be matched.

If the filter matches the item, this function must return True. If the item should be filtered out, False must be returned.

drop_closures_CustomFilterFunc :: CustomFilterFunc -> CustomFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CustomFilterFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_CustomFilterFunc

-> a

item: The item to be matched

-> Ptr ()

userData: user data

-> m Bool

Returns: True to keep the item around

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

genClosure_CustomFilterFunc :: MonadIO m => CustomFilterFunc -> m (GClosure C_CustomFilterFunc)

Wrap the callback into a GClosure.

mk_CustomFilterFunc :: C_CustomFilterFunc -> IO (FunPtr C_CustomFilterFunc)

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

noCustomFilterFunc :: Maybe CustomFilterFunc

A convenience synonym for Nothing :: Maybe CustomFilterFunc.

noCustomFilterFunc_WithClosures :: Maybe CustomFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe CustomFilterFunc_WithClosures.

wrap_CustomFilterFunc :: Maybe (Ptr (FunPtr C_CustomFilterFunc)) -> CustomFilterFunc_WithClosures -> C_CustomFilterFunc

Wrap a CustomFilterFunc into a C_CustomFilterFunc.

CustomMeasureFunc

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

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

type CustomMeasureFunc

Arguments

 = Widget

widget: the widget to be measured

-> Orientation

orientation: the direction to be measured

-> Int32

forSize: the size to be measured for

-> IO (Int32, Int32, Int32, Int32)

A function to be used by GtkCustomLayout to measure a widget.

dynamic_CustomMeasureFunc

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_CustomMeasureFunc

-> a

widget: the widget to be measured

-> Orientation

orientation: the direction to be measured

-> Int32

forSize: the size to be measured for

-> m (Int32, Int32, Int32, Int32)

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

genClosure_CustomMeasureFunc :: MonadIO m => CustomMeasureFunc -> m (GClosure C_CustomMeasureFunc)

Wrap the callback into a GClosure.

mk_CustomMeasureFunc :: C_CustomMeasureFunc -> IO (FunPtr C_CustomMeasureFunc)

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

noCustomMeasureFunc :: Maybe CustomMeasureFunc

A convenience synonym for Nothing :: Maybe CustomMeasureFunc.

wrap_CustomMeasureFunc :: Maybe (Ptr (FunPtr C_CustomMeasureFunc)) -> CustomMeasureFunc -> C_CustomMeasureFunc

Wrap a CustomMeasureFunc into a C_CustomMeasureFunc.

CustomRequestModeFunc

type C_CustomRequestModeFunc = Ptr Widget -> IO CUInt

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

type CustomRequestModeFunc

Arguments

 = Widget

widget: the widget to be queried

-> IO SizeRequestMode

Returns: the size request mode

Queries a widget for its preferred size request mode.

dynamic_CustomRequestModeFunc

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_CustomRequestModeFunc

-> a

widget: the widget to be queried

-> m SizeRequestMode

Returns: the size request mode

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

genClosure_CustomRequestModeFunc :: MonadIO m => CustomRequestModeFunc -> m (GClosure C_CustomRequestModeFunc)

Wrap the callback into a GClosure.

mk_CustomRequestModeFunc :: C_CustomRequestModeFunc -> IO (FunPtr C_CustomRequestModeFunc)

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

noCustomRequestModeFunc :: Maybe CustomRequestModeFunc

A convenience synonym for Nothing :: Maybe CustomRequestModeFunc.

wrap_CustomRequestModeFunc :: Maybe (Ptr (FunPtr C_CustomRequestModeFunc)) -> CustomRequestModeFunc -> C_CustomRequestModeFunc

Wrap a CustomRequestModeFunc into a C_CustomRequestModeFunc.

DrawingAreaDrawFunc

type C_DrawingAreaDrawFunc = Ptr DrawingArea -> Ptr Context -> Int32 -> Int32 -> Ptr () -> IO ()

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

type DrawingAreaDrawFunc

Arguments

 = DrawingArea

drawingArea: the GtkDrawingArea to redraw

-> Context

cr: the context to draw to

-> Int32

width: the actual width of the contents. This value will be at least as wide as GtkDrawingArea:width.

-> Int32

height: the actual height of the contents. This value will be at least as wide as GtkDrawingArea:height.

-> IO ()

Whenever drawingArea needs to redraw, this function will be called.

This function should exclusively redraw the contents of the drawing area and must not call any widget functions that cause changes.

type DrawingAreaDrawFunc_WithClosures

Arguments

 = DrawingArea

drawingArea: the GtkDrawingArea to redraw

-> Context

cr: the context to draw to

-> Int32

width: the actual width of the contents. This value will be at least as wide as GtkDrawingArea:width.

-> Int32

height: the actual height of the contents. This value will be at least as wide as GtkDrawingArea:height.

-> Ptr ()

userData: user data

-> IO ()

Whenever drawingArea needs to redraw, this function will be called.

This function should exclusively redraw the contents of the drawing area and must not call any widget functions that cause changes.

drop_closures_DrawingAreaDrawFunc :: DrawingAreaDrawFunc -> DrawingAreaDrawFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_DrawingAreaDrawFunc

Arguments

:: (HasCallStack, MonadIO m, IsDrawingArea a)

=> FunPtr C_DrawingAreaDrawFunc

-> a

drawingArea: the GtkDrawingArea to redraw

-> Context

cr: the context to draw to

-> Int32

width: the actual width of the contents. This value will be at least as wide as GtkDrawingArea:width.

-> Int32

height: the actual height of the contents. This value will be at least as wide as GtkDrawingArea:height.

-> Ptr ()

userData: user data

-> m ()

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

genClosure_DrawingAreaDrawFunc :: MonadIO m => DrawingAreaDrawFunc -> m (GClosure C_DrawingAreaDrawFunc)

Wrap the callback into a GClosure.

mk_DrawingAreaDrawFunc :: C_DrawingAreaDrawFunc -> IO (FunPtr C_DrawingAreaDrawFunc)

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

noDrawingAreaDrawFunc :: Maybe DrawingAreaDrawFunc

A convenience synonym for Nothing :: Maybe DrawingAreaDrawFunc.

noDrawingAreaDrawFunc_WithClosures :: Maybe DrawingAreaDrawFunc_WithClosures

A convenience synonym for Nothing :: Maybe DrawingAreaDrawFunc_WithClosures.

wrap_DrawingAreaDrawFunc :: Maybe (Ptr (FunPtr C_DrawingAreaDrawFunc)) -> DrawingAreaDrawFunc_WithClosures -> C_DrawingAreaDrawFunc

Wrap a DrawingAreaDrawFunc into a C_DrawingAreaDrawFunc.

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 GtkEntryCompletion

-> Text

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

-> TreeIter

iter: a GtkTreeIter 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_editable_get_text (GTK_EDITABLE (gtk_entry_completion_get_entry ())).

type EntryCompletionMatchFunc_WithClosures

Arguments

 = EntryCompletion

completion: the GtkEntryCompletion

-> Text

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

-> TreeIter

iter: a GtkTreeIter 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_editable_get_text (GTK_EDITABLE (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 GtkEntryCompletion

-> Text

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

-> TreeIter

iter: a GtkTreeIter 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.

ExpressionNotify

type C_ExpressionNotify = Ptr () -> IO ()

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

type ExpressionNotify = IO ()

Callback called by expressionWatch when the expression value changes.

type ExpressionNotify_WithClosures

Arguments

 = Ptr ()

userData: data passed to expressionWatch

-> IO ()

Callback called by expressionWatch when the expression value changes.

drop_closures_ExpressionNotify :: ExpressionNotify -> ExpressionNotify_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ExpressionNotify

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ExpressionNotify

-> Ptr ()

userData: data passed to expressionWatch

-> m ()

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

genClosure_ExpressionNotify :: MonadIO m => ExpressionNotify -> m (GClosure C_ExpressionNotify)

Wrap the callback into a GClosure.

mk_ExpressionNotify :: C_ExpressionNotify -> IO (FunPtr C_ExpressionNotify)

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

noExpressionNotify :: Maybe ExpressionNotify

A convenience synonym for Nothing :: Maybe ExpressionNotify.

noExpressionNotify_WithClosures :: Maybe ExpressionNotify_WithClosures

A convenience synonym for Nothing :: Maybe ExpressionNotify_WithClosures.

wrap_ExpressionNotify :: Maybe (Ptr (FunPtr C_ExpressionNotify)) -> ExpressionNotify_WithClosures -> C_ExpressionNotify

Wrap a ExpressionNotify into a C_ExpressionNotify.

FlowBoxCreateWidgetFunc

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

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

type FlowBoxCreateWidgetFunc

Arguments

 = Object

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

-> IO Widget

Returns: a GtkWidget that represents item

Called for flow boxes that are bound to a GListModel.

This function is called for each item that gets added to the model.

type FlowBoxCreateWidgetFunc_WithClosures

Arguments

 = Object

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

-> Ptr ()

userData: user data from flowBoxBindModel

-> IO Widget

Returns: a GtkWidget that represents item

Called for flow boxes that are bound to a GListModel.

This function is called for each item that gets added to the model.

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

-> a

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

-> Ptr ()

userData: user data from flowBoxBindModel

-> m Widget

Returns: a GtkWidget 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 GtkFlowBoxChild that may be filtered

-> IO Bool

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

A function that will be called whenever a child changes or is added.

It lets you control if the child should be visible or not.

type FlowBoxFilterFunc_WithClosures

Arguments

 = FlowBoxChild

child: a GtkFlowBoxChild 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 whenever a child changes or is added.

It lets you control if the child should be visible or not.

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

-> FlowBoxChild

child: a GtkFlowBoxChild

-> IO ()

A function used by flowBoxSelectedForeach.

It will be called on every selected child of the box.

type FlowBoxForeachFunc_WithClosures

Arguments

 = FlowBox

box: a GtkFlowBox

-> FlowBoxChild

child: a GtkFlowBoxChild

-> Ptr ()

userData: user data

-> IO ()

A function used by flowBoxSelectedForeach.

It will be called on every selected child of the box.

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 GtkFlowBox

-> b

child: a GtkFlowBoxChild

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

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.

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 PangoFontFamily

-> FontFace

face: a PangoFontFace 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 GtkFontChooser.

See fontChooserSetFilterFunc.

type FontFilterFunc_WithClosures

Arguments

 = FontFamily

family: a PangoFontFamily

-> FontFace

face: a PangoFontFace 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 GtkFontChooser.

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 PangoFontFamily

-> b

face: a PangoFontFace 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 GtkIconView

-> TreePath

path: The GtkTreePath 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 GtkIconView

-> TreePath

path: The GtkTreePath 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 GtkIconView

-> TreePath

path: The GtkTreePath 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.

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 GtkWidget that represents item

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

If the widget returned is not a ListBoxRow widget, then the widget will be inserted as the child of an intermediate ListBoxRow.

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 GtkWidget that represents item

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

If the widget returned is not a ListBoxRow widget, then the widget will be inserted as the child of an intermediate ListBoxRow.

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

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.

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 GtkListBox

-> ListBoxRow

row: a GtkListBoxRow

-> IO ()

A function used by listBoxSelectedForeach.

It will be called on every selected child of the box.

type ListBoxForeachFunc_WithClosures

Arguments

 = ListBox

box: a GtkListBox

-> ListBoxRow

row: a GtkListBoxRow

-> Ptr ()

userData: user data

-> IO ()

A function used by listBoxSelectedForeach.

It will be called on every selected child of the box.

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 GtkListBox

-> b

row: a GtkListBoxRow

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

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.

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.

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.

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.

MapListModelMapFunc

type C_MapListModelMapFunc = Ptr Object -> Ptr () -> IO (Ptr Object)

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

type MapListModelMapFunc

Arguments

 = Object

item: The item to map

-> IO Object

Returns: The item to map to

User function that is called to map an item of the original model to an item expected by the map model.

The returned items must conform to the item type of the model they are used with.

type MapListModelMapFunc_WithClosures

Arguments

 = Object

item: The item to map

-> Ptr ()

userData: user data

-> IO Object

Returns: The item to map to

User function that is called to map an item of the original model to an item expected by the map model.

The returned items must conform to the item type of the model they are used with.

drop_closures_MapListModelMapFunc :: MapListModelMapFunc -> MapListModelMapFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MapListModelMapFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_MapListModelMapFunc

-> a

item: The item to map

-> Ptr ()

userData: user data

-> m Object

Returns: The item to map to

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

genClosure_MapListModelMapFunc :: MonadIO m => MapListModelMapFunc -> m (GClosure C_MapListModelMapFunc)

Wrap the callback into a GClosure.

mk_MapListModelMapFunc :: C_MapListModelMapFunc -> IO (FunPtr C_MapListModelMapFunc)

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

noMapListModelMapFunc :: Maybe MapListModelMapFunc

A convenience synonym for Nothing :: Maybe MapListModelMapFunc.

noMapListModelMapFunc_WithClosures :: Maybe MapListModelMapFunc_WithClosures

A convenience synonym for Nothing :: Maybe MapListModelMapFunc_WithClosures.

wrap_MapListModelMapFunc :: Maybe (Ptr (FunPtr C_MapListModelMapFunc)) -> MapListModelMapFunc_WithClosures -> C_MapListModelMapFunc

Wrap a MapListModelMapFunc into a C_MapListModelMapFunc.

MenuButtonCreatePopupFunc

type C_MenuButtonCreatePopupFunc = Ptr MenuButton -> Ptr () -> IO ()

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

type MenuButtonCreatePopupFunc

Arguments

 = MenuButton

menuButton: the GtkMenuButton

-> IO ()

User-provided callback function to create a popup for a GtkMenuButton on demand.

This function is called when the popup of menuButton is shown, but none has been provided via menuButtonSetPopover or menuButtonSetMenuModel.

type MenuButtonCreatePopupFunc_WithClosures

Arguments

 = MenuButton

menuButton: the GtkMenuButton

-> Ptr ()

userData: User data passed to menuButtonSetCreatePopupFunc

-> IO ()

User-provided callback function to create a popup for a GtkMenuButton on demand.

This function is called when the popup of menuButton is shown, but none has been provided via menuButtonSetPopover or menuButtonSetMenuModel.

drop_closures_MenuButtonCreatePopupFunc :: MenuButtonCreatePopupFunc -> MenuButtonCreatePopupFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MenuButtonCreatePopupFunc

Arguments

:: (HasCallStack, MonadIO m, IsMenuButton a)

=> FunPtr C_MenuButtonCreatePopupFunc

-> a

menuButton: the GtkMenuButton

-> Ptr ()

userData: User data passed to menuButtonSetCreatePopupFunc

-> m ()

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

genClosure_MenuButtonCreatePopupFunc :: MonadIO m => MenuButtonCreatePopupFunc -> m (GClosure C_MenuButtonCreatePopupFunc)

Wrap the callback into a GClosure.

mk_MenuButtonCreatePopupFunc :: C_MenuButtonCreatePopupFunc -> IO (FunPtr C_MenuButtonCreatePopupFunc)

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

noMenuButtonCreatePopupFunc :: Maybe MenuButtonCreatePopupFunc

A convenience synonym for Nothing :: Maybe MenuButtonCreatePopupFunc.

noMenuButtonCreatePopupFunc_WithClosures :: Maybe MenuButtonCreatePopupFunc_WithClosures

A convenience synonym for Nothing :: Maybe MenuButtonCreatePopupFunc_WithClosures.

wrap_MenuButtonCreatePopupFunc :: Maybe (Ptr (FunPtr C_MenuButtonCreatePopupFunc)) -> MenuButtonCreatePopupFunc_WithClosures -> C_MenuButtonCreatePopupFunc

Wrap a MenuButtonCreatePopupFunc into a C_MenuButtonCreatePopupFunc.

PageSetupDoneFunc

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

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

type PageSetupDoneFunc

Arguments

 = PageSetup

pageSetup: the GtkPageSetup 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.

type PageSetupDoneFunc_WithClosures

Arguments

 = PageSetup

pageSetup: the GtkPageSetup that has been passed to printRunPageSetupDialogAsync

-> 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 GtkPageSetup that has been passed to printRunPageSetupDialogAsync

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

PrintJobCompleteFunc

type C_PrintJobCompleteFunc = Ptr PrintJob -> Ptr () -> Ptr GError -> IO ()

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

type PrintJobCompleteFunc

Arguments

 = PrintJob

printJob: the GtkPrintJob

-> GError

error: a GError that contains error information if the sending of the print job failed, otherwise Nothing

-> IO ()

The type of callback that is passed to printJobSend.

It is called when the print job has been completely sent.

type PrintJobCompleteFunc_WithClosures

Arguments

 = PrintJob

printJob: the GtkPrintJob

-> Ptr ()

userData: user data that has been passed to printJobSend

-> GError

error: a GError that contains error information if the sending of the print job failed, otherwise Nothing

-> IO ()

The type of callback that is passed to printJobSend.

It is called when the print job has been completely sent.

drop_closures_PrintJobCompleteFunc :: PrintJobCompleteFunc -> PrintJobCompleteFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PrintJobCompleteFunc

Arguments

:: (HasCallStack, MonadIO m, IsPrintJob a)

=> FunPtr C_PrintJobCompleteFunc

-> a

printJob: the GtkPrintJob

-> Ptr ()

userData: user data that has been passed to printJobSend

-> GError

error: a GError that contains error information if the sending of the print job failed, otherwise Nothing

-> m ()

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

genClosure_PrintJobCompleteFunc :: MonadIO m => PrintJobCompleteFunc -> m (GClosure C_PrintJobCompleteFunc)

Wrap the callback into a GClosure.

mk_PrintJobCompleteFunc :: C_PrintJobCompleteFunc -> IO (FunPtr C_PrintJobCompleteFunc)

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

noPrintJobCompleteFunc :: Maybe PrintJobCompleteFunc

A convenience synonym for Nothing :: Maybe PrintJobCompleteFunc.

noPrintJobCompleteFunc_WithClosures :: Maybe PrintJobCompleteFunc_WithClosures

A convenience synonym for Nothing :: Maybe PrintJobCompleteFunc_WithClosures.

wrap_PrintJobCompleteFunc :: Maybe (Ptr (FunPtr C_PrintJobCompleteFunc)) -> PrintJobCompleteFunc_WithClosures -> C_PrintJobCompleteFunc

Wrap a PrintJobCompleteFunc into a C_PrintJobCompleteFunc.

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.

PrinterFunc

type C_PrinterFunc = Ptr Printer -> Ptr () -> IO CInt

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

type PrinterFunc

Arguments

 = Printer

printer: a GtkPrinter

-> IO Bool

Returns: True to stop the enumeration, False to continue

The type of function passed to enumeratePrinters.

Note that you need to ref printer, if you want to keep a reference to it after the function has returned.

type PrinterFunc_WithClosures

Arguments

 = Printer

printer: a GtkPrinter

-> Ptr ()

data: user data passed to enumeratePrinters

-> IO Bool

Returns: True to stop the enumeration, False to continue

The type of function passed to enumeratePrinters.

Note that you need to ref printer, if you want to keep a reference to it after the function has returned.

drop_closures_PrinterFunc :: PrinterFunc -> PrinterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PrinterFunc

Arguments

:: (HasCallStack, MonadIO m, IsPrinter a)

=> FunPtr C_PrinterFunc

-> a

printer: a GtkPrinter

-> Ptr ()

data: user data passed to enumeratePrinters

-> m Bool

Returns: True to stop the enumeration, False to continue

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

genClosure_PrinterFunc :: MonadIO m => PrinterFunc -> m (GClosure C_PrinterFunc)

Wrap the callback into a GClosure.

mk_PrinterFunc :: C_PrinterFunc -> IO (FunPtr C_PrinterFunc)

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

noPrinterFunc :: Maybe PrinterFunc

A convenience synonym for Nothing :: Maybe PrinterFunc.

noPrinterFunc_WithClosures :: Maybe PrinterFunc_WithClosures

A convenience synonym for Nothing :: Maybe PrinterFunc_WithClosures.

wrap_PrinterFunc :: Maybe (Ptr (FunPtr C_PrinterFunc)) -> PrinterFunc_WithClosures -> C_PrinterFunc

Wrap a PrinterFunc into a C_PrinterFunc.

ScaleFormatValueFunc

type C_ScaleFormatValueFunc = Ptr Scale -> CDouble -> Ptr () -> IO CString

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

type ScaleFormatValueFunc

Arguments

 = Scale

scale: The GtkScale

-> Double

value: The numeric value to format

-> IO Text

Returns: A newly allocated string describing a textual representation of the given numerical value.

No description available in the introspection data.

type ScaleFormatValueFunc_WithClosures

Arguments

 = Scale

scale: The GtkScale

-> Double

value: The numeric value to format

-> Ptr ()

userData: user data

-> IO Text

Returns: A newly allocated string describing a textual representation of the given numerical value.

No description available in the introspection data.

drop_closures_ScaleFormatValueFunc :: ScaleFormatValueFunc -> ScaleFormatValueFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ScaleFormatValueFunc

Arguments

:: (HasCallStack, MonadIO m, IsScale a)

=> FunPtr C_ScaleFormatValueFunc

-> a

scale: The GtkScale

-> Double

value: The numeric value to format

-> Ptr ()

userData: user data

-> m Text

Returns: A newly allocated string describing a textual representation of the given numerical value.

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

genClosure_ScaleFormatValueFunc :: MonadIO m => ScaleFormatValueFunc -> m (GClosure C_ScaleFormatValueFunc)

Wrap the callback into a GClosure.

mk_ScaleFormatValueFunc :: C_ScaleFormatValueFunc -> IO (FunPtr C_ScaleFormatValueFunc)

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

noScaleFormatValueFunc :: Maybe ScaleFormatValueFunc

A convenience synonym for Nothing :: Maybe ScaleFormatValueFunc.

noScaleFormatValueFunc_WithClosures :: Maybe ScaleFormatValueFunc_WithClosures

A convenience synonym for Nothing :: Maybe ScaleFormatValueFunc_WithClosures.

wrap_ScaleFormatValueFunc :: Maybe (Ptr (FunPtr C_ScaleFormatValueFunc)) -> ScaleFormatValueFunc_WithClosures -> C_ScaleFormatValueFunc

Wrap a ScaleFormatValueFunc into a C_ScaleFormatValueFunc.

ShortcutFunc

type C_ShortcutFunc = Ptr Widget -> Ptr GVariant -> Ptr () -> IO CInt

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

type ShortcutFunc

Arguments

 = Widget

widget: The widget passed to the activation

-> Maybe GVariant

args: The arguments passed to the activation

-> IO Bool

Returns: True if the action was successful.

Prototype for shortcuts based on user callbacks.

type ShortcutFunc_WithClosures

Arguments

 = Widget

widget: The widget passed to the activation

-> Maybe GVariant

args: The arguments passed to the activation

-> Ptr ()

userData: The user data provided when activating the action

-> IO Bool

Returns: True if the action was successful.

Prototype for shortcuts based on user callbacks.

drop_closures_ShortcutFunc :: ShortcutFunc -> ShortcutFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ShortcutFunc

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_ShortcutFunc

-> a

widget: The widget passed to the activation

-> Maybe GVariant

args: The arguments passed to the activation

-> Ptr ()

userData: The user data provided when activating the action

-> m Bool

Returns: True if the action was successful.

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

genClosure_ShortcutFunc :: MonadIO m => ShortcutFunc -> m (GClosure C_ShortcutFunc)

Wrap the callback into a GClosure.

mk_ShortcutFunc :: C_ShortcutFunc -> IO (FunPtr C_ShortcutFunc)

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

noShortcutFunc :: Maybe ShortcutFunc

A convenience synonym for Nothing :: Maybe ShortcutFunc.

noShortcutFunc_WithClosures :: Maybe ShortcutFunc_WithClosures

A convenience synonym for Nothing :: Maybe ShortcutFunc_WithClosures.

wrap_ShortcutFunc :: Maybe (Ptr (FunPtr C_ShortcutFunc)) -> ShortcutFunc_WithClosures -> C_ShortcutFunc

Wrap a ShortcutFunc into a C_ShortcutFunc.

TextCharPredicate

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

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

type TextCharPredicate

Arguments

 = Char

ch: a Unicode code point

-> IO Bool

Returns: True if the predicate is satisfied, and the iteration should stop, and False otherwise

The predicate function used by textIterForwardFindChar and textIterBackwardFindChar.

type TextCharPredicate_WithClosures

Arguments

 = Char

ch: a Unicode code point

-> Ptr ()

userData: data passed to the callback

-> IO Bool

Returns: True if the predicate is satisfied, and the iteration should stop, and False otherwise

The predicate function used by textIterForwardFindChar and textIterBackwardFindChar.

drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TextCharPredicate

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TextCharPredicate

-> Char

ch: a Unicode code point

-> Ptr ()

userData: data passed to the callback

-> m Bool

Returns: True if the predicate is satisfied, and the iteration should stop, and False otherwise

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 GtkTextTag

-> IO ()

A function used with textTagTableForeach, to iterate over every GtkTextTag inside a GtkTextTagTable.

type TextTagTableForeach_WithClosures

Arguments

 = TextTag

tag: the GtkTextTag

-> Ptr ()

data: data passed to textTagTableForeach

-> IO ()

A function used with textTagTableForeach, to iterate over every GtkTextTag inside a GtkTextTagTable.

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 GtkTextTag

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

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.

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.

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 GtkTreeViewColumn

-> CellRenderer

cell: The GtkCellRenderer that is being rendered by treeColumn

-> TreeModel

treeModel: The GtkTreeModel being rendered

-> TreeIter

iter: A GtkTreeIter 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 function 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.

See also: treeViewColumnSetCellDataFunc

type TreeCellDataFunc_WithClosures

Arguments

 = TreeViewColumn

treeColumn: A GtkTreeViewColumn

-> CellRenderer

cell: The GtkCellRenderer that is being rendered by treeColumn

-> TreeModel

treeModel: The GtkTreeModel being rendered

-> TreeIter

iter: A GtkTreeIter 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 function 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.

See also: 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 GtkTreeViewColumn

-> b

cell: The GtkCellRenderer that is being rendered by treeColumn

-> c

treeModel: The GtkTreeModel being rendered

-> TreeIter

iter: A GtkTreeIter 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.

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 GtkTreeModel the comparison is within

-> TreeIter

a: A GtkTreeIter in model

-> TreeIter

b: Another GtkTreeIter 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 GtkTreeSortable 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 GtkTreeModel the comparison is within

-> TreeIter

a: A GtkTreeIter in model

-> TreeIter

b: Another GtkTreeIter 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 GtkTreeSortable 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 GtkTreeModel the comparison is within

-> TreeIter

a: A GtkTreeIter in model

-> TreeIter

b: Another GtkTreeIter 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.

TreeListModelCreateModelFunc

type C_TreeListModelCreateModelFunc = Ptr Object -> Ptr () -> IO (Ptr ListModel)

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

type TreeListModelCreateModelFunc

Arguments

 = Object

item: The item that is being expanded

-> IO (Maybe ListModel)

Returns: The model tracking the children of item or Nothing if item can never have children

Prototype of the function called to create new child models when treeListRowSetExpanded is called.

This function can return Nothing to indicate that item is guaranteed to be a leaf node and will never have children. If it does not have children but may get children later, it should return an empty model that is filled once children arrive.

type TreeListModelCreateModelFunc_WithClosures

Arguments

 = Object

item: The item that is being expanded

-> Ptr ()

userData: User data passed when registering the function

-> IO (Maybe ListModel)

Returns: The model tracking the children of item or Nothing if item can never have children

Prototype of the function called to create new child models when treeListRowSetExpanded is called.

This function can return Nothing to indicate that item is guaranteed to be a leaf node and will never have children. If it does not have children but may get children later, it should return an empty model that is filled once children arrive.

drop_closures_TreeListModelCreateModelFunc :: TreeListModelCreateModelFunc -> TreeListModelCreateModelFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeListModelCreateModelFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_TreeListModelCreateModelFunc

-> a

item: The item that is being expanded

-> Ptr ()

userData: User data passed when registering the function

-> m (Maybe ListModel)

Returns: The model tracking the children of item or Nothing if item can never have children

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

genClosure_TreeListModelCreateModelFunc :: MonadIO m => TreeListModelCreateModelFunc -> m (GClosure C_TreeListModelCreateModelFunc)

Wrap the callback into a GClosure.

mk_TreeListModelCreateModelFunc :: C_TreeListModelCreateModelFunc -> IO (FunPtr C_TreeListModelCreateModelFunc)

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

noTreeListModelCreateModelFunc :: Maybe TreeListModelCreateModelFunc

A convenience synonym for Nothing :: Maybe TreeListModelCreateModelFunc.

noTreeListModelCreateModelFunc_WithClosures :: Maybe TreeListModelCreateModelFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeListModelCreateModelFunc_WithClosures.

wrap_TreeListModelCreateModelFunc :: Maybe (Ptr (FunPtr C_TreeListModelCreateModelFunc)) -> TreeListModelCreateModelFunc_WithClosures -> C_TreeListModelCreateModelFunc

Wrap a TreeListModelCreateModelFunc into a C_TreeListModelCreateModelFunc.

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 GtkTreeModelFilter

-> TreeIter

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

-> GValue

value: A GValue which is already initialized for with the correct type for the column column.

-> Int32

column: the column whose display value is determined

-> IO ()

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 GtkTreeModelFilter

-> TreeIter

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

-> GValue

value: A GValue which is already initialized for with the correct type for the column column.

-> Int32

column: the column whose display value is determined

-> Ptr ()

data: user data given to treeModelFilterSetModifyFunc

-> IO ()

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 GtkTreeModelFilter

-> TreeIter

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

-> GValue

value: A GValue which is already initialized for with the correct type for the column column.

-> Int32

column: the column whose display value is determined

-> Ptr ()

data: user data given to treeModelFilterSetModifyFunc

-> m ()

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 GtkTreeModelFilter

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeModelFilter

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeModelFilter

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeModel being iterated

-> TreePath

path: the current GtkTreePath

-> TreeIter

iter: the current GtkTreeIter

-> 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 GtkTreeModel being iterated

-> TreePath

path: the current GtkTreePath

-> TreeIter

iter: the current GtkTreeIter

-> 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 GtkTreeModel being iterated

-> TreePath

path: the current GtkTreePath

-> TreeIter

iter: the current GtkTreeIter

-> 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 GtkTreeModel being viewed

-> TreePath

path: The GtkTreePath of a selected row

-> TreeIter

iter: A GtkTreeIter 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 GtkTreeModel being viewed

-> TreePath

path: The GtkTreePath of a selected row

-> TreeIter

iter: A GtkTreeIter 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 GtkTreeModel being viewed

-> TreePath

path: The GtkTreePath of a selected row

-> TreeIter

iter: A GtkTreeIter 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 GtkTreeSelection

-> TreeModel

model: A GtkTreeModel being viewed

-> TreePath

path: The GtkTreePath 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 GtkTreeSelection

-> TreeModel

model: A GtkTreeModel being viewed

-> TreePath

path: The GtkTreePath 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 GtkTreeSelection

-> b

model: A GtkTreeModel being viewed

-> TreePath

path: The GtkTreePath 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 GtkTreeView

-> TreeViewColumn

column: The GtkTreeViewColumn being dragged

-> TreeViewColumn

prevColumn: A GtkTreeViewColumn on one side of column

-> TreeViewColumn

nextColumn: A GtkTreeViewColumn 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 GtkTreeView

-> TreeViewColumn

column: The GtkTreeViewColumn being dragged

-> TreeViewColumn

prevColumn: A GtkTreeViewColumn on one side of column

-> TreeViewColumn

nextColumn: A GtkTreeViewColumn 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 GtkTreeView

-> b

column: The GtkTreeViewColumn being dragged

-> c

prevColumn: A GtkTreeViewColumn on one side of column

-> d

nextColumn: A GtkTreeViewColumn 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 GtkTreeView

-> TreePath

path: The path that’s expanded

-> IO ()

Function used for treeViewMapExpandedRows.

type TreeViewMappingFunc_WithClosures

Arguments

 = TreeView

treeView: A GtkTreeView

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

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

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeViewRowSeparatorFunc returns.

type TreeViewRowSeparatorFunc_WithClosures

Arguments

 = TreeModel

model: the GtkTreeModel

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeViewRowSeparatorFunc 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 GtkTreeModel

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

iter: a GtkTreeIter 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 GtkTreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

iter: a GtkTreeIter 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.

WidgetActionActivateFunc

type C_WidgetActionActivateFunc = Ptr Widget -> CString -> Ptr GVariant -> IO ()

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

type WidgetActionActivateFunc

Arguments

 = Widget

widget: the widget to which the action belongs

-> Text

actionName: the action name

-> GVariant

parameter: parameter for activation

-> IO ()

The type of the callback functions used for activating actions installed with widgetClassInstallAction.

The parameter must match the parameterType of the action.

dynamic_WidgetActionActivateFunc

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetActionActivateFunc

-> a

widget: the widget to which the action belongs

-> Text

actionName: the action name

-> GVariant

parameter: parameter for activation

-> m ()

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

genClosure_WidgetActionActivateFunc :: MonadIO m => WidgetActionActivateFunc -> m (GClosure C_WidgetActionActivateFunc)

Wrap the callback into a GClosure.

mk_WidgetActionActivateFunc :: C_WidgetActionActivateFunc -> IO (FunPtr C_WidgetActionActivateFunc)

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

noWidgetActionActivateFunc :: Maybe WidgetActionActivateFunc

A convenience synonym for Nothing :: Maybe WidgetActionActivateFunc.

wrap_WidgetActionActivateFunc :: Maybe (Ptr (FunPtr C_WidgetActionActivateFunc)) -> WidgetActionActivateFunc -> C_WidgetActionActivateFunc

Wrap a WidgetActionActivateFunc into a C_WidgetActionActivateFunc.

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.

WidgetClassContainsFieldCallback

type C_WidgetClassContainsFieldCallback = Ptr Widget -> CDouble -> CDouble -> IO CInt

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

type WidgetClassContainsFieldCallback

Arguments

 = Widget

widget: the widget to query

-> Double

x: X coordinate to test, relative to widget's origin

-> Double

y: Y coordinate to test, relative to widget's origin

-> IO Bool

Returns: True if widget contains (x, y).

No description available in the introspection data.

dynamic_WidgetClassContainsFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassContainsFieldCallback

-> a

widget: the widget to query

-> Double

x: X coordinate to test, relative to widget's origin

-> Double

y: Y coordinate to test, relative to widget's origin

-> m Bool

Returns: True if widget contains (x, y).

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

genClosure_WidgetClassContainsFieldCallback :: MonadIO m => WidgetClassContainsFieldCallback -> m (GClosure C_WidgetClassContainsFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassContainsFieldCallback :: C_WidgetClassContainsFieldCallback -> IO (FunPtr C_WidgetClassContainsFieldCallback)

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

noWidgetClassContainsFieldCallback :: Maybe WidgetClassContainsFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassContainsFieldCallback.

wrap_WidgetClassContainsFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassContainsFieldCallback)) -> WidgetClassContainsFieldCallback -> C_WidgetClassContainsFieldCallback

Wrap a WidgetClassContainsFieldCallback into a C_WidgetClassContainsFieldCallback.

WidgetClassCssChangedFieldCallback

type C_WidgetClassCssChangedFieldCallback = Ptr Widget -> Ptr CssStyleChange -> IO ()

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

type WidgetClassCssChangedFieldCallback = Widget -> CssStyleChange -> IO ()

No description available in the introspection data.

dynamic_WidgetClassCssChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCssChangedFieldCallback -> a -> CssStyleChange -> m ()

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

genClosure_WidgetClassCssChangedFieldCallback :: MonadIO m => WidgetClassCssChangedFieldCallback -> m (GClosure C_WidgetClassCssChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassCssChangedFieldCallback :: C_WidgetClassCssChangedFieldCallback -> IO (FunPtr C_WidgetClassCssChangedFieldCallback)

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

noWidgetClassCssChangedFieldCallback :: Maybe WidgetClassCssChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassCssChangedFieldCallback.

wrap_WidgetClassCssChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)) -> WidgetClassCssChangedFieldCallback -> C_WidgetClassCssChangedFieldCallback

Wrap a WidgetClassCssChangedFieldCallback into a C_WidgetClassCssChangedFieldCallback.

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.

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.

WidgetClassGetRequestModeFieldCallback

type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt

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

type WidgetClassGetRequestModeFieldCallback

Arguments

 = Widget

widget: a GtkWidget instance

-> IO SizeRequestMode

Returns: The GtkSizeRequestMode preferred by widget.

No description available in the introspection data.

dynamic_WidgetClassGetRequestModeFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGetRequestModeFieldCallback

-> a

widget: a GtkWidget instance

-> m SizeRequestMode

Returns: The GtkSizeRequestMode 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.

WidgetClassGrabFocusFieldCallback

type C_WidgetClassGrabFocusFieldCallback = Ptr Widget -> IO CInt

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

type WidgetClassGrabFocusFieldCallback

Arguments

 = Widget

widget: a GtkWidget

-> IO Bool

Returns: True if focus is now inside widget.

No description available in the introspection data.

dynamic_WidgetClassGrabFocusFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassGrabFocusFieldCallback

-> a

widget: a GtkWidget

-> m Bool

Returns: True if focus is now inside widget.

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.

WidgetClassHideFieldCallback

type C_WidgetClassHideFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassHideFieldCallback

Arguments

 = Widget

widget: a GtkWidget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassHideFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassHideFieldCallback

-> a

widget: a GtkWidget

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

WidgetClassKeynavFailedFieldCallback

type C_WidgetClassKeynavFailedFieldCallback = Ptr Widget -> CUInt -> IO CInt

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

type WidgetClassKeynavFailedFieldCallback

Arguments

 = Widget

widget: a GtkWidget

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

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

WidgetClassMapFieldCallback

type C_WidgetClassMapFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassMapFieldCallback

Arguments

 = Widget

widget: a GtkWidget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassMapFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassMapFieldCallback

-> a

widget: a GtkWidget

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

WidgetClassMeasureFieldCallback

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

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

type WidgetClassMeasureFieldCallback

Arguments

 = Widget

widget: A GtkWidget instance

-> Orientation

orientation: the orientation to measure

-> Int32

forSize: Size for the opposite of orientation, i.e. if orientation is OrientationHorizontal, this is the height the widget should be measured with. The OrientationVertical case is analogous. This way, both height-for-width and width-for-height requests can be implemented. If no size is known, -1 can be passed.

-> IO (Int32, Int32, Int32, Int32)

No description available in the introspection data.

dynamic_WidgetClassMeasureFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassMeasureFieldCallback

-> a

widget: A GtkWidget instance

-> Orientation

orientation: the orientation to measure

-> Int32

forSize: Size for the opposite of orientation, i.e. if orientation is OrientationHorizontal, this is the height the widget should be measured with. The OrientationVertical case is analogous. This way, both height-for-width and width-for-height requests can be implemented. If no size is known, -1 can be passed.

-> m (Int32, Int32, Int32, Int32)

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

genClosure_WidgetClassMeasureFieldCallback :: MonadIO m => WidgetClassMeasureFieldCallback -> m (GClosure C_WidgetClassMeasureFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassMeasureFieldCallback :: C_WidgetClassMeasureFieldCallback -> IO (FunPtr C_WidgetClassMeasureFieldCallback)

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

noWidgetClassMeasureFieldCallback :: Maybe WidgetClassMeasureFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassMeasureFieldCallback.

wrap_WidgetClassMeasureFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMeasureFieldCallback)) -> WidgetClassMeasureFieldCallback -> C_WidgetClassMeasureFieldCallback

Wrap a WidgetClassMeasureFieldCallback into a C_WidgetClassMeasureFieldCallback.

WidgetClassMnemonicActivateFieldCallback

type C_WidgetClassMnemonicActivateFieldCallback = Ptr Widget -> CInt -> IO CInt

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

type WidgetClassMnemonicActivateFieldCallback

Arguments

 = Widget

widget: a GtkWidget

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

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

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.

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.

WidgetClassRealizeFieldCallback

type C_WidgetClassRealizeFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassRealizeFieldCallback

Arguments

 = Widget

widget: a GtkWidget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassRealizeFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassRealizeFieldCallback

-> a

widget: a GtkWidget

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

WidgetClassRootFieldCallback

type C_WidgetClassRootFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassRootFieldCallback = Widget -> IO ()

No description available in the introspection data.

dynamic_WidgetClassRootFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassRootFieldCallback -> a -> m ()

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

genClosure_WidgetClassRootFieldCallback :: MonadIO m => WidgetClassRootFieldCallback -> m (GClosure C_WidgetClassRootFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassRootFieldCallback :: C_WidgetClassRootFieldCallback -> IO (FunPtr C_WidgetClassRootFieldCallback)

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

noWidgetClassRootFieldCallback :: Maybe WidgetClassRootFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassRootFieldCallback.

wrap_WidgetClassRootFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRootFieldCallback)) -> WidgetClassRootFieldCallback -> C_WidgetClassRootFieldCallback

Wrap a WidgetClassRootFieldCallback into a C_WidgetClassRootFieldCallback.

WidgetClassSetFocusChildFieldCallback

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

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

type WidgetClassSetFocusChildFieldCallback

Arguments

 = Widget

widget: a GtkWidget

-> Maybe Widget

child: a direct child widget of widget or Nothing to unset the focus child of widget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassSetFocusChildFieldCallback

Arguments

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

=> FunPtr C_WidgetClassSetFocusChildFieldCallback

-> a

widget: a GtkWidget

-> Maybe b

child: a direct child widget of widget or Nothing to unset the focus child of widget

-> m ()

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

genClosure_WidgetClassSetFocusChildFieldCallback :: MonadIO m => WidgetClassSetFocusChildFieldCallback -> m (GClosure C_WidgetClassSetFocusChildFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSetFocusChildFieldCallback :: C_WidgetClassSetFocusChildFieldCallback -> IO (FunPtr C_WidgetClassSetFocusChildFieldCallback)

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

noWidgetClassSetFocusChildFieldCallback :: Maybe WidgetClassSetFocusChildFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSetFocusChildFieldCallback.

wrap_WidgetClassSetFocusChildFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)) -> WidgetClassSetFocusChildFieldCallback -> C_WidgetClassSetFocusChildFieldCallback

Wrap a WidgetClassSetFocusChildFieldCallback into a C_WidgetClassSetFocusChildFieldCallback.

WidgetClassShowFieldCallback

type C_WidgetClassShowFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassShowFieldCallback

Arguments

 = Widget

widget: a GtkWidget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassShowFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassShowFieldCallback

-> a

widget: a GtkWidget

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

WidgetClassSizeAllocateFieldCallback

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

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

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

No description available in the introspection data.

dynamic_WidgetClassSizeAllocateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSizeAllocateFieldCallback -> a -> Int32 -> Int32 -> Int32 -> 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.

WidgetClassSnapshotFieldCallback

type C_WidgetClassSnapshotFieldCallback = Ptr Widget -> Ptr Snapshot -> IO ()

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

type WidgetClassSnapshotFieldCallback = Widget -> Snapshot -> IO ()

No description available in the introspection data.

dynamic_WidgetClassSnapshotFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsSnapshot b) => FunPtr C_WidgetClassSnapshotFieldCallback -> a -> b -> m ()

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

genClosure_WidgetClassSnapshotFieldCallback :: MonadIO m => WidgetClassSnapshotFieldCallback -> m (GClosure C_WidgetClassSnapshotFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSnapshotFieldCallback :: C_WidgetClassSnapshotFieldCallback -> IO (FunPtr C_WidgetClassSnapshotFieldCallback)

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

noWidgetClassSnapshotFieldCallback :: Maybe WidgetClassSnapshotFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSnapshotFieldCallback.

wrap_WidgetClassSnapshotFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)) -> WidgetClassSnapshotFieldCallback -> C_WidgetClassSnapshotFieldCallback

Wrap a WidgetClassSnapshotFieldCallback into a C_WidgetClassSnapshotFieldCallback.

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.

WidgetClassSystemSettingChangedFieldCallback

type C_WidgetClassSystemSettingChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

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

type WidgetClassSystemSettingChangedFieldCallback = Widget -> SystemSetting -> IO ()

No description available in the introspection data.

dynamic_WidgetClassSystemSettingChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSystemSettingChangedFieldCallback -> a -> SystemSetting -> m ()

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

genClosure_WidgetClassSystemSettingChangedFieldCallback :: MonadIO m => WidgetClassSystemSettingChangedFieldCallback -> m (GClosure C_WidgetClassSystemSettingChangedFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassSystemSettingChangedFieldCallback :: C_WidgetClassSystemSettingChangedFieldCallback -> IO (FunPtr C_WidgetClassSystemSettingChangedFieldCallback)

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

noWidgetClassSystemSettingChangedFieldCallback :: Maybe WidgetClassSystemSettingChangedFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassSystemSettingChangedFieldCallback.

wrap_WidgetClassSystemSettingChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSystemSettingChangedFieldCallback)) -> WidgetClassSystemSettingChangedFieldCallback -> C_WidgetClassSystemSettingChangedFieldCallback

Wrap a WidgetClassSystemSettingChangedFieldCallback into a C_WidgetClassSystemSettingChangedFieldCallback.

WidgetClassUnmapFieldCallback

type C_WidgetClassUnmapFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassUnmapFieldCallback

Arguments

 = Widget

widget: a GtkWidget

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassUnmapFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassUnmapFieldCallback

-> a

widget: a GtkWidget

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

-> IO ()

No description available in the introspection data.

dynamic_WidgetClassUnrealizeFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_WidgetClassUnrealizeFieldCallback

-> a

widget: a GtkWidget

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

WidgetClassUnrootFieldCallback

type C_WidgetClassUnrootFieldCallback = Ptr Widget -> IO ()

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

type WidgetClassUnrootFieldCallback = Widget -> IO ()

No description available in the introspection data.

dynamic_WidgetClassUnrootFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnrootFieldCallback -> a -> m ()

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

genClosure_WidgetClassUnrootFieldCallback :: MonadIO m => WidgetClassUnrootFieldCallback -> m (GClosure C_WidgetClassUnrootFieldCallback)

Wrap the callback into a GClosure.

mk_WidgetClassUnrootFieldCallback :: C_WidgetClassUnrootFieldCallback -> IO (FunPtr C_WidgetClassUnrootFieldCallback)

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

noWidgetClassUnrootFieldCallback :: Maybe WidgetClassUnrootFieldCallback

A convenience synonym for Nothing :: Maybe WidgetClassUnrootFieldCallback.

wrap_WidgetClassUnrootFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrootFieldCallback)) -> WidgetClassUnrootFieldCallback -> C_WidgetClassUnrootFieldCallback

Wrap a WidgetClassUnrootFieldCallback into a C_WidgetClassUnrootFieldCallback.