gi-gtk-4.0.4: Gtk bindings
CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria
Safe HaskellSafe-Inferred
LanguageHaskell2010

GI.Gtk.Callbacks

Contents

Description

 
Synopsis

Signals

AssistantPageFunc

type AssistantPageFunc Source #

Arguments

 = Int32

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

-> IO Int32

Returns: The next page number.

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

type AssistantPageFunc_WithClosures Source #

Arguments

 = Int32

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

-> Ptr ()

data: user data.

-> IO Int32

Returns: The next page number.

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

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

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

drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_AssistantPageFunc Source #

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) Source #

Wrap the callback into a GClosure.

mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc) Source #

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

BuildableParserEndElementFieldCallback

type BuildableParserEndElementFieldCallback Source #

Arguments

 = BuildableParseContext 
-> Text 
-> IO ()

(Can throw GError)

No description available in the introspection data.

type BuildableParserEndElementFieldCallback_WithClosures Source #

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 () Source #

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

dynamic_BuildableParserEndElementFieldCallback Source #

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

BuildableParserErrorFieldCallback

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

No description available in the introspection data.

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

No description available in the introspection data.

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

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

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

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

BuildableParserStartElementFieldCallback

type BuildableParserStartElementFieldCallback Source #

Arguments

 = BuildableParseContext 
-> Text 
-> Text 
-> Text 
-> IO ()

(Can throw GError)

No description available in the introspection data.

type BuildableParserStartElementFieldCallback_WithClosures Source #

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 () Source #

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

dynamic_BuildableParserStartElementFieldCallback Source #

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.

BuildableParserTextFieldCallback

type BuildableParserTextFieldCallback Source #

Arguments

 = BuildableParseContext 
-> Text 
-> Word64 
-> IO ()

(Can throw GError)

No description available in the introspection data.

type BuildableParserTextFieldCallback_WithClosures Source #

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 () Source #

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

dynamic_BuildableParserTextFieldCallback Source #

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.

CellAllocCallback

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

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

type CellAllocCallback Source #

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> Rectangle

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

-> Rectangle

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

-> IO Bool

Returns: True to stop iterating over cells.

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

type CellAllocCallback_WithClosures Source #

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> Rectangle

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

-> Rectangle

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

-> Ptr ()

data: user-supplied data

-> IO Bool

Returns: True to stop iterating over cells.

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

drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CellAllocCallback Source #

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) Source #

Wrap the callback into a GClosure.

mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback) Source #

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

CellCallback

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

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

type CellCallback Source #

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> IO Bool

Returns: True to stop iterating over cells.

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

type CellCallback_WithClosures Source #

Arguments

 = CellRenderer

renderer: the cell renderer to operate on

-> Ptr ()

data: user-supplied data

-> IO Bool

Returns: True to stop iterating over cells.

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

drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CellCallback Source #

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) Source #

Wrap the callback into a GClosure.

mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback) Source #

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

CellLayoutDataFunc

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

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

type CellLayoutDataFunc Source #

Arguments

 = CellLayout

cellLayout: a CellLayout

-> CellRenderer

cell: the cell renderer whose value is to be set

-> TreeModel

treeModel: the model

-> TreeIter

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

-> IO () 

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

type CellLayoutDataFunc_WithClosures Source #

Arguments

 = CellLayout

cellLayout: a CellLayout

-> CellRenderer

cell: the cell renderer whose value is to be set

-> TreeModel

treeModel: the model

-> TreeIter

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

-> Ptr ()

data: user data passed to cellLayoutSetCellDataFunc

-> IO () 

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

drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CellLayoutDataFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b, IsTreeModel c) 
=> FunPtr C_CellLayoutDataFunc 
-> a

cellLayout: a CellLayout

-> b

cell: the cell renderer whose value is to be set

-> c

treeModel: the model

-> TreeIter

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

-> Ptr ()

data: user data passed to cellLayoutSetCellDataFunc

-> m () 

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

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

Wrap the callback into a GClosure.

mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc) Source #

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

CustomAllocateFunc

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

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

type CustomAllocateFunc Source #

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 CustomLayout to allocate a widget.

dynamic_CustomAllocateFunc Source #

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) Source #

Wrap the callback into a GClosure.

mk_CustomAllocateFunc :: C_CustomAllocateFunc -> IO (FunPtr C_CustomAllocateFunc) Source #

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

CustomFilterFunc

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

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

type CustomFilterFunc Source #

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 Source #

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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_CustomFilterFunc Source #

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) Source #

Wrap the callback into a GClosure.

mk_CustomFilterFunc :: C_CustomFilterFunc -> IO (FunPtr C_CustomFilterFunc) Source #

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

CustomMeasureFunc

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

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

type CustomMeasureFunc Source #

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 CustomLayout to measure a widget.

dynamic_CustomMeasureFunc Source #

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) Source #

Wrap the callback into a GClosure.

mk_CustomMeasureFunc :: C_CustomMeasureFunc -> IO (FunPtr C_CustomMeasureFunc) Source #

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

CustomRequestModeFunc

type C_CustomRequestModeFunc = Ptr Widget -> IO CUInt Source #

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

type CustomRequestModeFunc Source #

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 Source #

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) Source #

Wrap the callback into a GClosure.

mk_CustomRequestModeFunc :: C_CustomRequestModeFunc -> IO (FunPtr C_CustomRequestModeFunc) Source #

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

DrawingAreaDrawFunc

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

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

type DrawingAreaDrawFunc Source #

Arguments

 = DrawingArea

drawingArea: the DrawingArea 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 Source #

Arguments

 = DrawingArea

drawingArea: the DrawingArea 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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_DrawingAreaDrawFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDrawingArea a) 
=> FunPtr C_DrawingAreaDrawFunc 
-> a

drawingArea: the DrawingArea 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) Source #

Wrap the callback into a GClosure.

mk_DrawingAreaDrawFunc :: C_DrawingAreaDrawFunc -> IO (FunPtr C_DrawingAreaDrawFunc) Source #

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

EntryCompletionMatchFunc

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

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

type EntryCompletionMatchFunc Source #

Arguments

 = EntryCompletion

completion: the EntryCompletion

-> Text

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

-> TreeIter

iter: a TreeIter indicating the row to match

-> IO Bool

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

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

type EntryCompletionMatchFunc_WithClosures Source #

Arguments

 = EntryCompletion

completion: the EntryCompletion

-> Text

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

-> TreeIter

iter: a TreeIter indicating the row to match

-> Ptr ()

userData: user data given to entryCompletionSetMatchFunc

-> IO Bool

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

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

dynamic_EntryCompletionMatchFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsEntryCompletion a) 
=> FunPtr C_EntryCompletionMatchFunc 
-> a

completion: the EntryCompletion

-> Text

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

-> TreeIter

iter: a TreeIter indicating the row to match

-> Ptr ()

userData: user data given to entryCompletionSetMatchFunc

-> m Bool

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

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

ExpressionNotify

type C_ExpressionNotify = Ptr () -> IO () Source #

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

type ExpressionNotify = IO () Source #

Callback called by expressionWatch when the expression value changes.

type ExpressionNotify_WithClosures Source #

Arguments

 = Ptr ()

userData: data passed to expressionWatch

-> IO () 

Callback called by expressionWatch when the expression value changes.

drop_closures_ExpressionNotify :: ExpressionNotify -> ExpressionNotify_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ExpressionNotify Source #

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) Source #

Wrap the callback into a GClosure.

mk_ExpressionNotify :: C_ExpressionNotify -> IO (FunPtr C_ExpressionNotify) Source #

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

FlowBoxCreateWidgetFunc

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

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

type FlowBoxCreateWidgetFunc Source #

Arguments

 = Object

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

-> IO Widget

Returns: a Widget that represents item

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

type FlowBoxCreateWidgetFunc_WithClosures Source #

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

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

dynamic_FlowBoxCreateWidgetFunc Source #

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

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

FlowBoxFilterFunc

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

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

type FlowBoxFilterFunc Source #

Arguments

 = FlowBoxChild

child: a FlowBoxChild that may be filtered

-> IO Bool

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

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

type FlowBoxFilterFunc_WithClosures Source #

Arguments

 = FlowBoxChild

child: a FlowBoxChild that may be filtered

-> Ptr ()

userData: user data

-> IO Bool

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

A function that will be called 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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxFilterFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsFlowBoxChild a) 
=> FunPtr C_FlowBoxFilterFunc 
-> a

child: a FlowBoxChild that may be filtered

-> Ptr ()

userData: user data

-> m Bool

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

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

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

Wrap the callback into a GClosure.

mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc) Source #

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

FlowBoxForeachFunc

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

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

type FlowBoxForeachFunc Source #

Arguments

 = FlowBox

box: a FlowBox

-> FlowBoxChild

child: a FlowBoxChild

-> IO () 

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

type FlowBoxForeachFunc_WithClosures Source #

Arguments

 = FlowBox

box: a FlowBox

-> FlowBoxChild

child: a FlowBoxChild

-> Ptr ()

userData: user data

-> IO () 

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

drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) 
=> FunPtr C_FlowBoxForeachFunc 
-> a

box: a FlowBox

-> b

child: a FlowBoxChild

-> Ptr ()

userData: user data

-> m () 

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

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

Wrap the callback into a GClosure.

mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc) Source #

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

FlowBoxSortFunc

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

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

type FlowBoxSortFunc Source #

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 Source #

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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxSortFunc Source #

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) Source #

Wrap the callback into a GClosure.

mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc) Source #

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

FontFilterFunc

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

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

type FontFilterFunc Source #

Arguments

 = FontFamily

family: a FontFamily

-> FontFace

face: a FontFace belonging to family

-> IO Bool

Returns: True if the font should be displayed

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

type FontFilterFunc_WithClosures Source #

Arguments

 = FontFamily

family: a FontFamily

-> FontFace

face: a FontFace belonging to family

-> Ptr ()

data: user data passed to fontChooserSetFilterFunc

-> IO Bool

Returns: True if the font should be displayed

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

drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FontFilterFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsFontFamily a, IsFontFace b) 
=> FunPtr C_FontFilterFunc 
-> a

family: a FontFamily

-> b

face: a FontFace belonging to family

-> Ptr ()

data: user data passed to fontChooserSetFilterFunc

-> m Bool

Returns: True if the font should be displayed

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

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

Wrap the callback into a GClosure.

mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc) Source #

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

IconViewForeachFunc

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

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

type IconViewForeachFunc Source #

Arguments

 = IconView

iconView: a IconView

-> TreePath

path: The TreePath of a selected row

-> IO () 

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

type IconViewForeachFunc_WithClosures Source #

Arguments

 = IconView

iconView: a IconView

-> TreePath

path: The TreePath of a selected row

-> Ptr ()

data: user data

-> IO () 

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

drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_IconViewForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsIconView a) 
=> FunPtr C_IconViewForeachFunc 
-> a

iconView: a IconView

-> TreePath

path: The TreePath of a selected row

-> Ptr ()

data: user data

-> m () 

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

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

Wrap the callback into a GClosure.

mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc) Source #

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

ListBoxCreateWidgetFunc

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

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

type ListBoxCreateWidgetFunc Source #

Arguments

 = Object

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

-> IO Widget

Returns: a Widget that represents item

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

type ListBoxCreateWidgetFunc_WithClosures Source #

Arguments

 = Object

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

-> Ptr ()

userData: user data

-> IO Widget

Returns: a Widget that represents item

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

dynamic_ListBoxCreateWidgetFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) 
=> FunPtr C_ListBoxCreateWidgetFunc 
-> a

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

-> Ptr ()

userData: user data

-> m Widget

Returns: a Widget that represents item

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

ListBoxFilterFunc

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

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

type ListBoxFilterFunc Source #

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 Source #

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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxFilterFunc Source #

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) Source #

Wrap the callback into a GClosure.

mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc) Source #

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

ListBoxForeachFunc

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

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

type ListBoxForeachFunc Source #

Arguments

 = ListBox

box: a ListBox

-> ListBoxRow

row: a ListBoxRow

-> IO () 

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

type ListBoxForeachFunc_WithClosures Source #

Arguments

 = ListBox

box: a ListBox

-> ListBoxRow

row: a ListBoxRow

-> Ptr ()

userData: user data

-> IO () 

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

drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) 
=> FunPtr C_ListBoxForeachFunc 
-> a

box: a ListBox

-> b

row: a ListBoxRow

-> Ptr ()

userData: user data

-> m () 

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

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

Wrap the callback into a GClosure.

mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc) Source #

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

ListBoxSortFunc

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

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

type ListBoxSortFunc Source #

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 Source #

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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxSortFunc Source #

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) Source #

Wrap the callback into a GClosure.

mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc) Source #

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

ListBoxUpdateHeaderFunc

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

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

type ListBoxUpdateHeaderFunc Source #

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 Source #

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.

dynamic_ListBoxUpdateHeaderFunc Source #

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.

MapListModelMapFunc

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

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

type MapListModelMapFunc Source #

Arguments

 = Object

item: The item to map

-> IO Object

Returns: The item to map to. This function may not return Nothing

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 Source #

Arguments

 = Object

item: The item to map

-> Ptr ()

userData: user data

-> IO Object

Returns: The item to map to. This function may not return Nothing

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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_MapListModelMapFunc Source #

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. This function may not return Nothing

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) Source #

Wrap the callback into a GClosure.

mk_MapListModelMapFunc :: C_MapListModelMapFunc -> IO (FunPtr C_MapListModelMapFunc) Source #

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

MenuButtonCreatePopupFunc

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

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

type MenuButtonCreatePopupFunc Source #

Arguments

 = MenuButton

menuButton: the MenuButton

-> IO () 

User-provided callback function to create a popup for menuButton 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 Source #

Arguments

 = MenuButton

menuButton: the MenuButton

-> Ptr ()

userData: User data passed to menuButtonSetCreatePopupFunc

-> IO () 

User-provided callback function to create a popup for menuButton on demand. This function is called when the popup of menuButton is shown, but none has been provided via menuButtonSetPopover or menuButtonSetMenuModel.

dynamic_MenuButtonCreatePopupFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenuButton a) 
=> FunPtr C_MenuButtonCreatePopupFunc 
-> a

menuButton: the MenuButton

-> Ptr ()

userData: User data passed to menuButtonSetCreatePopupFunc

-> m () 

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

PageSetupDoneFunc

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

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

type PageSetupDoneFunc Source #

Arguments

 = PageSetup

pageSetup: the PageSetup 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 Source #

Arguments

 = PageSetup

pageSetup: the PageSetup 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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_PageSetupDoneFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsPageSetup a) 
=> FunPtr C_PageSetupDoneFunc 
-> a

pageSetup: the PageSetup 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) Source #

Wrap the callback into a GClosure.

mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc) Source #

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

PrintSettingsFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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) Source #

Wrap the callback into a GClosure.

mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc) Source #

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

ScaleFormatValueFunc

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

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

type ScaleFormatValueFunc Source #

Arguments

 = Scale

scale: The Scale

-> 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 Source #

Arguments

 = Scale

scale: The Scale

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

dynamic_ScaleFormatValueFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsScale a) 
=> FunPtr C_ScaleFormatValueFunc 
-> a

scale: The Scale

-> 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) Source #

Wrap the callback into a GClosure.

mk_ScaleFormatValueFunc :: C_ScaleFormatValueFunc -> IO (FunPtr C_ScaleFormatValueFunc) Source #

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

ShortcutFunc

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

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

type ShortcutFunc Source #

Arguments

 = Widget

widget: The widget passed to the activation

-> Maybe GVariant

args: The arguments passed to the activation

-> IO Bool 

Prototype for shortcuts based on user callbacks.

type ShortcutFunc_WithClosures Source #

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 

Prototype for shortcuts based on user callbacks.

drop_closures_ShortcutFunc :: ShortcutFunc -> ShortcutFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ShortcutFunc Source #

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 

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) Source #

Wrap the callback into a GClosure.

mk_ShortcutFunc :: C_ShortcutFunc -> IO (FunPtr C_ShortcutFunc) Source #

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

TextCharPredicate

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

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

type TextCharPredicate Source #

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 Source #

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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextCharPredicate Source #

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) Source #

Wrap the callback into a GClosure.

mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate) Source #

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

TextTagTableForeach

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

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

type TextTagTableForeach Source #

Arguments

 = TextTag

tag: the TextTag

-> IO () 

A function used with textTagTableForeach, to iterate over every TextTag inside a TextTagTable.

type TextTagTableForeach_WithClosures Source #

Arguments

 = TextTag

tag: the TextTag

-> Ptr ()

data: data passed to textTagTableForeach

-> IO () 

A function used with textTagTableForeach, to iterate over every TextTag inside a TextTagTable.

drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextTagTableForeach Source #

Arguments

:: (HasCallStack, MonadIO m, IsTextTag a) 
=> FunPtr C_TextTagTableForeach 
-> a

tag: the TextTag

-> Ptr ()

data: data passed to textTagTableForeach

-> m () 

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

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

Wrap the callback into a GClosure.

mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach) Source #

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

TickCallback

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

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

type TickCallback Source #

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 Source #

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 Source #

A simple wrapper that ignores the closure arguments.

dynamic_TickCallback Source #

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) Source #

Wrap the callback into a GClosure.

mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback) Source #

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

TreeCellDataFunc

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

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

type TreeCellDataFunc Source #

Arguments

 = TreeViewColumn

treeColumn: A TreeViewColumn

-> CellRenderer

cell: The CellRenderer that is being rendered by treeColumn

-> TreeModel

treeModel: The TreeModel being rendered

-> TreeIter

iter: A TreeIter of the current row rendered

-> IO () 

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

type TreeCellDataFunc_WithClosures Source #

Arguments

 = TreeViewColumn

treeColumn: A TreeViewColumn

-> CellRenderer

cell: The CellRenderer that is being rendered by treeColumn

-> TreeModel

treeModel: The TreeModel being rendered

-> TreeIter

iter: A TreeIter of the current row rendered

-> Ptr ()

data: user data

-> IO () 

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

drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeCellDataFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b, IsTreeModel c) 
=> FunPtr C_TreeCellDataFunc 
-> a

treeColumn: A TreeViewColumn

-> b

cell: The CellRenderer that is being rendered by treeColumn

-> c

treeModel: The TreeModel being rendered

-> TreeIter

iter: A TreeIter of the current row rendered

-> Ptr ()

data: user data

-> m () 

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

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

Wrap the callback into a GClosure.

mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc) Source #

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

TreeIterCompareFunc

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

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

type TreeIterCompareFunc Source #

Arguments

 = TreeModel

model: The TreeModel the comparison is within

-> TreeIter

a: A TreeIter in model

-> TreeIter

b: Another TreeIter in model

-> IO Int32

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

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

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

type TreeIterCompareFunc_WithClosures Source #

Arguments

 = TreeModel

model: The TreeModel the comparison is within

-> TreeIter

a: A TreeIter in model

-> TreeIter

b: Another TreeIter in model

-> Ptr ()

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

-> IO Int32

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

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

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

drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeIterCompareFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) 
=> FunPtr C_TreeIterCompareFunc 
-> a

model: The TreeModel the comparison is within

-> TreeIter

a: A TreeIter in model

-> TreeIter

b: Another TreeIter in model

-> Ptr ()

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

-> m Int32

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

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

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

Wrap the callback into a GClosure.

mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc) Source #

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

TreeListModelCreateModelFunc

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

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

type TreeListModelCreateModelFunc Source #

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 Source #

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.

dynamic_TreeListModelCreateModelFunc Source #

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.

TreeModelFilterModifyFunc

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

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

type TreeModelFilterModifyFunc Source #

Arguments

 = TreeModel

model: the TreeModelFilter

-> TreeIter

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

-> GValue

value: A Value 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 Source #

Arguments

 = TreeModel

model: the TreeModelFilter

-> TreeIter

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

-> GValue

value: A Value 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.

dynamic_TreeModelFilterModifyFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) 
=> FunPtr C_TreeModelFilterModifyFunc 
-> a

model: the TreeModelFilter

-> TreeIter

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

-> GValue

value: A Value 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.

TreeModelFilterVisibleFunc

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

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

type TreeModelFilterVisibleFunc Source #

Arguments

 = TreeModel

model: the child model of the TreeModelFilter

-> TreeIter

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

-> IO Bool

Returns: Whether the row indicated by iter is visible.

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

type TreeModelFilterVisibleFunc_WithClosures Source #

Arguments

 = TreeModel

model: the child model of the TreeModelFilter

-> TreeIter

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

-> Ptr ()

data: user data given to treeModelFilterSetVisibleFunc

-> IO Bool

Returns: Whether the row indicated by iter is visible.

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

dynamic_TreeModelFilterVisibleFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) 
=> FunPtr C_TreeModelFilterVisibleFunc 
-> a

model: the child model of the TreeModelFilter

-> TreeIter

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

-> Ptr ()

data: user data given to treeModelFilterSetVisibleFunc

-> m Bool

Returns: Whether the row indicated by iter is visible.

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

TreeModelForeachFunc

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

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

type TreeModelForeachFunc Source #

Arguments

 = TreeModel

model: the TreeModel being iterated

-> TreePath

path: the current TreePath

-> TreeIter

iter: the current TreeIter

-> IO Bool

Returns: True to stop iterating, False to continue

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

type TreeModelForeachFunc_WithClosures Source #

Arguments

 = TreeModel

model: the TreeModel being iterated

-> TreePath

path: the current TreePath

-> TreeIter

iter: the current TreeIter

-> Ptr ()

data: The user data passed to treeModelForeach

-> IO Bool

Returns: True to stop iterating, False to continue

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

dynamic_TreeModelForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) 
=> FunPtr C_TreeModelForeachFunc 
-> a

model: the TreeModel being iterated

-> TreePath

path: the current TreePath

-> TreeIter

iter: the current TreeIter

-> Ptr ()

data: The user data passed to treeModelForeach

-> m Bool

Returns: True to stop iterating, False to continue

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

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

Wrap the callback into a GClosure.

mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc) Source #

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

TreeSelectionForeachFunc

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

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

type TreeSelectionForeachFunc Source #

Arguments

 = TreeModel

model: The TreeModel being viewed

-> TreePath

path: The TreePath of a selected row

-> TreeIter

iter: A TreeIter pointing to a selected row

-> IO () 

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

type TreeSelectionForeachFunc_WithClosures Source #

Arguments

 = TreeModel

model: The TreeModel being viewed

-> TreePath

path: The TreePath of a selected row

-> TreeIter

iter: A TreeIter pointing to a selected row

-> Ptr ()

data: user data

-> IO () 

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

dynamic_TreeSelectionForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) 
=> FunPtr C_TreeSelectionForeachFunc 
-> a

model: The TreeModel being viewed

-> TreePath

path: The TreePath of a selected row

-> TreeIter

iter: A TreeIter pointing to a selected row

-> Ptr ()

data: user data

-> m () 

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

TreeSelectionFunc

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

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

type TreeSelectionFunc Source #

Arguments

 = TreeSelection

selection: A TreeSelection

-> TreeModel

model: A TreeModel being viewed

-> TreePath

path: The TreePath of the row in question

-> Bool

pathCurrentlySelected: True, if the path is currently selected

-> IO Bool

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

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

type TreeSelectionFunc_WithClosures Source #

Arguments

 = TreeSelection

selection: A TreeSelection

-> TreeModel

model: A TreeModel being viewed

-> TreePath

path: The TreePath of the row in question

-> Bool

pathCurrentlySelected: True, if the path is currently selected

-> Ptr ()

data: user data

-> IO Bool

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

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

drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeSelectionFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b) 
=> FunPtr C_TreeSelectionFunc 
-> a

selection: A TreeSelection

-> b

model: A TreeModel being viewed

-> TreePath

path: The TreePath of the row in question

-> Bool

pathCurrentlySelected: True, if the path is currently selected

-> Ptr ()

data: user data

-> m Bool

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

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

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

Wrap the callback into a GClosure.

mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc) Source #

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

TreeViewColumnDropFunc

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

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

type TreeViewColumnDropFunc Source #

Arguments

 = TreeView

treeView: A TreeView

-> TreeViewColumn

column: The TreeViewColumn being dragged

-> TreeViewColumn

prevColumn: A TreeViewColumn on one side of column

-> TreeViewColumn

nextColumn: A TreeViewColumn on the other side of column

-> IO Bool

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

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

type TreeViewColumnDropFunc_WithClosures Source #

Arguments

 = TreeView

treeView: A TreeView

-> TreeViewColumn

column: The TreeViewColumn being dragged

-> TreeViewColumn

prevColumn: A TreeViewColumn on one side of column

-> TreeViewColumn

nextColumn: A TreeViewColumn on the other side of column

-> Ptr ()

data: user data

-> IO Bool

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

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

dynamic_TreeViewColumnDropFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d) 
=> FunPtr C_TreeViewColumnDropFunc 
-> a

treeView: A TreeView

-> b

column: The TreeViewColumn being dragged

-> c

prevColumn: A TreeViewColumn on one side of column

-> d

nextColumn: A TreeViewColumn on the other side of column

-> Ptr ()

data: user data

-> m Bool

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

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

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

Wrap the callback into a GClosure.

TreeViewMappingFunc

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

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

type TreeViewMappingFunc Source #

Arguments

 = TreeView

treeView: A TreeView

-> TreePath

path: The path that’s expanded

-> IO () 

Function used for treeViewMapExpandedRows.

type TreeViewMappingFunc_WithClosures Source #

Arguments

 = TreeView

treeView: A TreeView

-> TreePath

path: The path that’s expanded

-> Ptr ()

userData: user data

-> IO () 

Function used for treeViewMapExpandedRows.

drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewMappingFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeView a) 
=> FunPtr C_TreeViewMappingFunc 
-> a

treeView: A TreeView

-> TreePath

path: The path that’s expanded

-> Ptr ()

userData: user data

-> m () 

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

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

Wrap the callback into a GClosure.

mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc) Source #

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

TreeViewRowSeparatorFunc

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

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

type TreeViewRowSeparatorFunc Source #

Arguments

 = TreeModel

model: the TreeModel

-> TreeIter

iter: a TreeIter pointing at a row in model

-> IO Bool

Returns: True if the row is a separator

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

type TreeViewRowSeparatorFunc_WithClosures Source #

Arguments

 = TreeModel

model: the TreeModel

-> TreeIter

iter: a TreeIter pointing at a row in model

-> Ptr ()

data: user data

-> IO Bool

Returns: True if the row is a separator

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

dynamic_TreeViewRowSeparatorFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) 
=> FunPtr C_TreeViewRowSeparatorFunc 
-> a

model: the TreeModel

-> TreeIter

iter: a TreeIter pointing at a row in model

-> Ptr ()

data: user data

-> m Bool

Returns: True if the row is a separator

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

TreeViewSearchEqualFunc

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

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

type TreeViewSearchEqualFunc Source #

Arguments

 = TreeModel

model: the TreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

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

-> IO Bool

Returns: False if the row matches, True otherwise.

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

type TreeViewSearchEqualFunc_WithClosures Source #

Arguments

 = TreeModel

model: the TreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

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

-> Ptr ()

searchData: user data from treeViewSetSearchEqualFunc

-> IO Bool

Returns: False if the row matches, True otherwise.

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

dynamic_TreeViewSearchEqualFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) 
=> FunPtr C_TreeViewSearchEqualFunc 
-> a

model: the TreeModel being searched

-> Int32

column: the search column set by treeViewSetSearchColumn

-> Text

key: the key string to compare with

-> TreeIter

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

-> Ptr ()

searchData: user data from treeViewSetSearchEqualFunc

-> m Bool

Returns: False if the row matches, True otherwise.

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

WidgetActionActivateFunc

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

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

type WidgetActionActivateFunc Source #

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 Source #

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.

WidgetClassComputeExpandFieldCallback

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

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

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

No description available in the introspection data.

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

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

WidgetClassContainsFieldCallback

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

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

type WidgetClassContainsFieldCallback Source #

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 Source #

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.

WidgetClassCssChangedFieldCallback

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

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

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

No description available in the introspection data.

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

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

WidgetClassDirectionChangedFieldCallback

type C_WidgetClassDirectionChangedFieldCallback = Ptr Widget -> CUInt -> IO () Source #

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

type WidgetClassDirectionChangedFieldCallback = Widget -> TextDirection -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDirectionChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDirectionChangedFieldCallback -> a -> TextDirection -> m () Source #

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

WidgetClassFocusFieldCallback

type C_WidgetClassFocusFieldCallback = Ptr Widget -> CUInt -> IO CInt Source #

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

type WidgetClassFocusFieldCallback = Widget -> DirectionType -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusFieldCallback -> a -> DirectionType -> m Bool Source #

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

WidgetClassGetRequestModeFieldCallback

type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt Source #

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

type WidgetClassGetRequestModeFieldCallback Source #

Arguments

 = Widget

widget: a Widget instance

-> IO SizeRequestMode

Returns: The SizeRequestMode preferred by widget.

No description available in the introspection data.

dynamic_WidgetClassGetRequestModeFieldCallback Source #

Arguments

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

widget: a Widget instance

-> m SizeRequestMode

Returns: The SizeRequestMode preferred by widget.

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

WidgetClassGrabFocusFieldCallback

type C_WidgetClassGrabFocusFieldCallback = Ptr Widget -> IO CInt Source #

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

type WidgetClassGrabFocusFieldCallback Source #

Arguments

 = Widget

widget: a Widget

-> IO Bool

Returns: True if focus is now inside widget.

No description available in the introspection data.

dynamic_WidgetClassGrabFocusFieldCallback Source #

Arguments

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

widget: a Widget

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

WidgetClassHideFieldCallback

type C_WidgetClassHideFieldCallback = Ptr Widget -> IO () Source #

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

type WidgetClassHideFieldCallback Source #

Arguments

 = Widget

widget: a