Copyright	Will Thompson and Iñaki García Etxebarria
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria
Safe Haskell	None
Language	Haskell2010

GI.Gtk.Callbacks

Contents

Signals

Description

Synopsis

type AssistantPageFunc = Int32 -> IO Int32
type AssistantPageFunc_WithClosures = Int32 -> Ptr () -> IO Int32
type C_AssistantPageFunc = Int32 -> Ptr () -> IO Int32
drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures
dynamic_AssistantPageFunc :: (HasCallStack, MonadIO m) => FunPtr C_AssistantPageFunc -> Int32 -> Ptr () -> m Int32
genClosure_AssistantPageFunc :: MonadIO m => AssistantPageFunc -> m (GClosure C_AssistantPageFunc)
mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)
noAssistantPageFunc :: Maybe AssistantPageFunc
noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures
wrap_AssistantPageFunc :: Maybe (Ptr (FunPtr C_AssistantPageFunc)) -> AssistantPageFunc_WithClosures -> C_AssistantPageFunc
type BuildableParserEndElementFieldCallback = BuildableParseContext -> Text -> IO ()
type BuildableParserEndElementFieldCallback_WithClosures = BuildableParseContext -> Text -> Ptr () -> IO ()
type C_BuildableParserEndElementFieldCallback = Ptr BuildableParseContext -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()
drop_closures_BuildableParserEndElementFieldCallback :: BuildableParserEndElementFieldCallback -> BuildableParserEndElementFieldCallback_WithClosures
dynamic_BuildableParserEndElementFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserEndElementFieldCallback -> BuildableParseContext -> Text -> Ptr () -> m ()
mk_BuildableParserEndElementFieldCallback :: C_BuildableParserEndElementFieldCallback -> IO (FunPtr C_BuildableParserEndElementFieldCallback)
noBuildableParserEndElementFieldCallback :: Maybe BuildableParserEndElementFieldCallback
noBuildableParserEndElementFieldCallback_WithClosures :: Maybe BuildableParserEndElementFieldCallback_WithClosures
type BuildableParserErrorFieldCallback = BuildableParseContext -> GError -> IO ()
type BuildableParserErrorFieldCallback_WithClosures = BuildableParseContext -> GError -> Ptr () -> IO ()
type C_BuildableParserErrorFieldCallback = Ptr BuildableParseContext -> Ptr GError -> Ptr () -> IO ()
drop_closures_BuildableParserErrorFieldCallback :: BuildableParserErrorFieldCallback -> BuildableParserErrorFieldCallback_WithClosures
dynamic_BuildableParserErrorFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserErrorFieldCallback -> BuildableParseContext -> GError -> Ptr () -> m ()
genClosure_BuildableParserErrorFieldCallback :: MonadIO m => BuildableParserErrorFieldCallback -> m (GClosure C_BuildableParserErrorFieldCallback)
mk_BuildableParserErrorFieldCallback :: C_BuildableParserErrorFieldCallback -> IO (FunPtr C_BuildableParserErrorFieldCallback)
noBuildableParserErrorFieldCallback :: Maybe BuildableParserErrorFieldCallback
noBuildableParserErrorFieldCallback_WithClosures :: Maybe BuildableParserErrorFieldCallback_WithClosures
wrap_BuildableParserErrorFieldCallback :: Maybe (Ptr (FunPtr C_BuildableParserErrorFieldCallback)) -> BuildableParserErrorFieldCallback_WithClosures -> C_BuildableParserErrorFieldCallback
type BuildableParserStartElementFieldCallback = BuildableParseContext -> Text -> Text -> Text -> IO ()
type BuildableParserStartElementFieldCallback_WithClosures = BuildableParseContext -> Text -> Text -> Text -> Ptr () -> IO ()
type C_BuildableParserStartElementFieldCallback = Ptr BuildableParseContext -> CString -> CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()
drop_closures_BuildableParserStartElementFieldCallback :: BuildableParserStartElementFieldCallback -> BuildableParserStartElementFieldCallback_WithClosures
dynamic_BuildableParserStartElementFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserStartElementFieldCallback -> BuildableParseContext -> Text -> Text -> Text -> Ptr () -> m ()
mk_BuildableParserStartElementFieldCallback :: C_BuildableParserStartElementFieldCallback -> IO (FunPtr C_BuildableParserStartElementFieldCallback)
noBuildableParserStartElementFieldCallback :: Maybe BuildableParserStartElementFieldCallback
noBuildableParserStartElementFieldCallback_WithClosures :: Maybe BuildableParserStartElementFieldCallback_WithClosures
type BuildableParserTextFieldCallback = BuildableParseContext -> Text -> CSize -> IO ()
type BuildableParserTextFieldCallback_WithClosures = BuildableParseContext -> Text -> CSize -> Ptr () -> IO ()
type C_BuildableParserTextFieldCallback = Ptr BuildableParseContext -> CString -> CSize -> Ptr () -> Ptr (Ptr GError) -> IO ()
drop_closures_BuildableParserTextFieldCallback :: BuildableParserTextFieldCallback -> BuildableParserTextFieldCallback_WithClosures
dynamic_BuildableParserTextFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserTextFieldCallback -> BuildableParseContext -> Text -> CSize -> Ptr () -> m ()
mk_BuildableParserTextFieldCallback :: C_BuildableParserTextFieldCallback -> IO (FunPtr C_BuildableParserTextFieldCallback)
noBuildableParserTextFieldCallback :: Maybe BuildableParserTextFieldCallback
noBuildableParserTextFieldCallback_WithClosures :: Maybe BuildableParserTextFieldCallback_WithClosures
type C_CellAllocCallback = Ptr CellRenderer -> Ptr Rectangle -> Ptr Rectangle -> Ptr () -> IO CInt
type CellAllocCallback = CellRenderer -> Rectangle -> Rectangle -> IO Bool
type CellAllocCallback_WithClosures = CellRenderer -> Rectangle -> Rectangle -> Ptr () -> IO Bool
drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures
dynamic_CellAllocCallback :: (HasCallStack, MonadIO m, IsCellRenderer a) => FunPtr C_CellAllocCallback -> a -> Rectangle -> Rectangle -> Ptr () -> m Bool
genClosure_CellAllocCallback :: MonadIO m => CellAllocCallback -> m (GClosure C_CellAllocCallback)
mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback)
noCellAllocCallback :: Maybe CellAllocCallback
noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures
wrap_CellAllocCallback :: Maybe (Ptr (FunPtr C_CellAllocCallback)) -> CellAllocCallback_WithClosures -> C_CellAllocCallback
type C_CellCallback = Ptr CellRenderer -> Ptr () -> IO CInt
type CellCallback = CellRenderer -> IO Bool
type CellCallback_WithClosures = CellRenderer -> Ptr () -> IO Bool
drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures
dynamic_CellCallback :: (HasCallStack, MonadIO m, IsCellRenderer a) => FunPtr C_CellCallback -> a -> Ptr () -> m Bool
genClosure_CellCallback :: MonadIO m => CellCallback -> m (GClosure C_CellCallback)
mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback)
noCellCallback :: Maybe CellCallback
noCellCallback_WithClosures :: Maybe CellCallback_WithClosures
wrap_CellCallback :: Maybe (Ptr (FunPtr C_CellCallback)) -> CellCallback_WithClosures -> C_CellCallback
type C_CellLayoutDataFunc = Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()
type CellLayoutDataFunc = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> IO ()
type CellLayoutDataFunc_WithClosures = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()
drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures
dynamic_CellLayoutDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b, IsTreeModel c) => FunPtr C_CellLayoutDataFunc -> a -> b -> c -> TreeIter -> Ptr () -> m ()
genClosure_CellLayoutDataFunc :: MonadIO m => CellLayoutDataFunc -> m (GClosure C_CellLayoutDataFunc)
mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc)
noCellLayoutDataFunc :: Maybe CellLayoutDataFunc
noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures
wrap_CellLayoutDataFunc :: Maybe (Ptr (FunPtr C_CellLayoutDataFunc)) -> CellLayoutDataFunc_WithClosures -> C_CellLayoutDataFunc
type C_CustomAllocateFunc = Ptr Widget -> Int32 -> Int32 -> Int32 -> IO ()
type CustomAllocateFunc = Widget -> Int32 -> Int32 -> Int32 -> IO ()
dynamic_CustomAllocateFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_CustomAllocateFunc -> a -> Int32 -> Int32 -> Int32 -> m ()
genClosure_CustomAllocateFunc :: MonadIO m => CustomAllocateFunc -> m (GClosure C_CustomAllocateFunc)
mk_CustomAllocateFunc :: C_CustomAllocateFunc -> IO (FunPtr C_CustomAllocateFunc)
noCustomAllocateFunc :: Maybe CustomAllocateFunc
wrap_CustomAllocateFunc :: Maybe (Ptr (FunPtr C_CustomAllocateFunc)) -> CustomAllocateFunc -> C_CustomAllocateFunc
type C_CustomFilterFunc = Ptr Object -> Ptr () -> IO CInt
type CustomFilterFunc = Object -> IO Bool
type CustomFilterFunc_WithClosures = Object -> Ptr () -> IO Bool
drop_closures_CustomFilterFunc :: CustomFilterFunc -> CustomFilterFunc_WithClosures
dynamic_CustomFilterFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_CustomFilterFunc -> a -> Ptr () -> m Bool
genClosure_CustomFilterFunc :: MonadIO m => CustomFilterFunc -> m (GClosure C_CustomFilterFunc)
mk_CustomFilterFunc :: C_CustomFilterFunc -> IO (FunPtr C_CustomFilterFunc)
noCustomFilterFunc :: Maybe CustomFilterFunc
noCustomFilterFunc_WithClosures :: Maybe CustomFilterFunc_WithClosures
wrap_CustomFilterFunc :: Maybe (Ptr (FunPtr C_CustomFilterFunc)) -> CustomFilterFunc_WithClosures -> C_CustomFilterFunc
type C_CustomMeasureFunc = Ptr Widget -> CUInt -> Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
type CustomMeasureFunc = Widget -> Orientation -> Int32 -> IO (Int32, Int32, Int32, Int32)
dynamic_CustomMeasureFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_CustomMeasureFunc -> a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)
genClosure_CustomMeasureFunc :: MonadIO m => CustomMeasureFunc -> m (GClosure C_CustomMeasureFunc)
mk_CustomMeasureFunc :: C_CustomMeasureFunc -> IO (FunPtr C_CustomMeasureFunc)
noCustomMeasureFunc :: Maybe CustomMeasureFunc
wrap_CustomMeasureFunc :: Maybe (Ptr (FunPtr C_CustomMeasureFunc)) -> CustomMeasureFunc -> C_CustomMeasureFunc
type C_CustomRequestModeFunc = Ptr Widget -> IO CUInt
type CustomRequestModeFunc = Widget -> IO SizeRequestMode
dynamic_CustomRequestModeFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_CustomRequestModeFunc -> a -> m SizeRequestMode
genClosure_CustomRequestModeFunc :: MonadIO m => CustomRequestModeFunc -> m (GClosure C_CustomRequestModeFunc)
mk_CustomRequestModeFunc :: C_CustomRequestModeFunc -> IO (FunPtr C_CustomRequestModeFunc)
noCustomRequestModeFunc :: Maybe CustomRequestModeFunc
wrap_CustomRequestModeFunc :: Maybe (Ptr (FunPtr C_CustomRequestModeFunc)) -> CustomRequestModeFunc -> C_CustomRequestModeFunc
type C_DrawingAreaDrawFunc = Ptr DrawingArea -> Ptr Context -> Int32 -> Int32 -> Ptr () -> IO ()
type DrawingAreaDrawFunc = DrawingArea -> Context -> Int32 -> Int32 -> IO ()
type DrawingAreaDrawFunc_WithClosures = DrawingArea -> Context -> Int32 -> Int32 -> Ptr () -> IO ()
drop_closures_DrawingAreaDrawFunc :: DrawingAreaDrawFunc -> DrawingAreaDrawFunc_WithClosures
dynamic_DrawingAreaDrawFunc :: (HasCallStack, MonadIO m, IsDrawingArea a) => FunPtr C_DrawingAreaDrawFunc -> a -> Context -> Int32 -> Int32 -> Ptr () -> m ()
genClosure_DrawingAreaDrawFunc :: MonadIO m => DrawingAreaDrawFunc -> m (GClosure C_DrawingAreaDrawFunc)
mk_DrawingAreaDrawFunc :: C_DrawingAreaDrawFunc -> IO (FunPtr C_DrawingAreaDrawFunc)
noDrawingAreaDrawFunc :: Maybe DrawingAreaDrawFunc
noDrawingAreaDrawFunc_WithClosures :: Maybe DrawingAreaDrawFunc_WithClosures
wrap_DrawingAreaDrawFunc :: Maybe (Ptr (FunPtr C_DrawingAreaDrawFunc)) -> DrawingAreaDrawFunc_WithClosures -> C_DrawingAreaDrawFunc
type C_EntryCompletionMatchFunc = Ptr EntryCompletion -> CString -> Ptr TreeIter -> Ptr () -> IO CInt
type EntryCompletionMatchFunc = EntryCompletion -> Text -> TreeIter -> IO Bool
type EntryCompletionMatchFunc_WithClosures = EntryCompletion -> Text -> TreeIter -> Ptr () -> IO Bool
drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures
dynamic_EntryCompletionMatchFunc :: (HasCallStack, MonadIO m, IsEntryCompletion a) => FunPtr C_EntryCompletionMatchFunc -> a -> Text -> TreeIter -> Ptr () -> m Bool
genClosure_EntryCompletionMatchFunc :: MonadIO m => EntryCompletionMatchFunc -> m (GClosure C_EntryCompletionMatchFunc)
mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc)
noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc
noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures
wrap_EntryCompletionMatchFunc :: Maybe (Ptr (FunPtr C_EntryCompletionMatchFunc)) -> EntryCompletionMatchFunc_WithClosures -> C_EntryCompletionMatchFunc
type C_ExpressionNotify = Ptr () -> IO ()
type ExpressionNotify = IO ()
type ExpressionNotify_WithClosures = Ptr () -> IO ()
drop_closures_ExpressionNotify :: ExpressionNotify -> ExpressionNotify_WithClosures
dynamic_ExpressionNotify :: (HasCallStack, MonadIO m) => FunPtr C_ExpressionNotify -> Ptr () -> m ()
genClosure_ExpressionNotify :: MonadIO m => ExpressionNotify -> m (GClosure C_ExpressionNotify)
mk_ExpressionNotify :: C_ExpressionNotify -> IO (FunPtr C_ExpressionNotify)
noExpressionNotify :: Maybe ExpressionNotify
noExpressionNotify_WithClosures :: Maybe ExpressionNotify_WithClosures
wrap_ExpressionNotify :: Maybe (Ptr (FunPtr C_ExpressionNotify)) -> ExpressionNotify_WithClosures -> C_ExpressionNotify
type C_FlowBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO (Ptr Widget)
type FlowBoxCreateWidgetFunc = Object -> IO Widget
type FlowBoxCreateWidgetFunc_WithClosures = Object -> Ptr () -> IO Widget
drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures
dynamic_FlowBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_FlowBoxCreateWidgetFunc -> a -> Ptr () -> m Widget
genClosure_FlowBoxCreateWidgetFunc :: MonadIO m => FlowBoxCreateWidgetFunc -> m (GClosure C_FlowBoxCreateWidgetFunc)
mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc)
noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc
noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures
wrap_FlowBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_FlowBoxCreateWidgetFunc)) -> FlowBoxCreateWidgetFunc_WithClosures -> C_FlowBoxCreateWidgetFunc
type C_FlowBoxFilterFunc = Ptr FlowBoxChild -> Ptr () -> IO CInt
type FlowBoxFilterFunc = FlowBoxChild -> IO Bool
type FlowBoxFilterFunc_WithClosures = FlowBoxChild -> Ptr () -> IO Bool
drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures
dynamic_FlowBoxFilterFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => FunPtr C_FlowBoxFilterFunc -> a -> Ptr () -> m Bool
genClosure_FlowBoxFilterFunc :: MonadIO m => FlowBoxFilterFunc -> m (GClosure C_FlowBoxFilterFunc)
mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc)
noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc
noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures
wrap_FlowBoxFilterFunc :: Maybe (Ptr (FunPtr C_FlowBoxFilterFunc)) -> FlowBoxFilterFunc_WithClosures -> C_FlowBoxFilterFunc
type C_FlowBoxForeachFunc = Ptr FlowBox -> Ptr FlowBoxChild -> Ptr () -> IO ()
type FlowBoxForeachFunc = FlowBox -> FlowBoxChild -> IO ()
type FlowBoxForeachFunc_WithClosures = FlowBox -> FlowBoxChild -> Ptr () -> IO ()
drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures
dynamic_FlowBoxForeachFunc :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => FunPtr C_FlowBoxForeachFunc -> a -> b -> Ptr () -> m ()
genClosure_FlowBoxForeachFunc :: MonadIO m => FlowBoxForeachFunc -> m (GClosure C_FlowBoxForeachFunc)
mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc)
noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc
noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures
wrap_FlowBoxForeachFunc :: Maybe (Ptr (FunPtr C_FlowBoxForeachFunc)) -> FlowBoxForeachFunc_WithClosures -> C_FlowBoxForeachFunc
type C_FlowBoxSortFunc = Ptr FlowBoxChild -> Ptr FlowBoxChild -> Ptr () -> IO Int32
type FlowBoxSortFunc = FlowBoxChild -> FlowBoxChild -> IO Int32
type FlowBoxSortFunc_WithClosures = FlowBoxChild -> FlowBoxChild -> Ptr () -> IO Int32
drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures
dynamic_FlowBoxSortFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a, IsFlowBoxChild b) => FunPtr C_FlowBoxSortFunc -> a -> b -> Ptr () -> m Int32
genClosure_FlowBoxSortFunc :: MonadIO m => FlowBoxSortFunc -> m (GClosure C_FlowBoxSortFunc)
mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc)
noFlowBoxSortFunc :: Maybe FlowBoxSortFunc
noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures
wrap_FlowBoxSortFunc :: Maybe (Ptr (FunPtr C_FlowBoxSortFunc)) -> FlowBoxSortFunc_WithClosures -> C_FlowBoxSortFunc
type C_FontFilterFunc = Ptr FontFamily -> Ptr FontFace -> Ptr () -> IO CInt
type FontFilterFunc = FontFamily -> FontFace -> IO Bool
type FontFilterFunc_WithClosures = FontFamily -> FontFace -> Ptr () -> IO Bool
drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures
dynamic_FontFilterFunc :: (HasCallStack, MonadIO m, IsFontFamily a, IsFontFace b) => FunPtr C_FontFilterFunc -> a -> b -> Ptr () -> m Bool
genClosure_FontFilterFunc :: MonadIO m => FontFilterFunc -> m (GClosure C_FontFilterFunc)
mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc)
noFontFilterFunc :: Maybe FontFilterFunc
noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures
wrap_FontFilterFunc :: Maybe (Ptr (FunPtr C_FontFilterFunc)) -> FontFilterFunc_WithClosures -> C_FontFilterFunc
type C_IconViewForeachFunc = Ptr IconView -> Ptr TreePath -> Ptr () -> IO ()
type IconViewForeachFunc = IconView -> TreePath -> IO ()
type IconViewForeachFunc_WithClosures = IconView -> TreePath -> Ptr () -> IO ()
drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures
dynamic_IconViewForeachFunc :: (HasCallStack, MonadIO m, IsIconView a) => FunPtr C_IconViewForeachFunc -> a -> TreePath -> Ptr () -> m ()
genClosure_IconViewForeachFunc :: MonadIO m => IconViewForeachFunc -> m (GClosure C_IconViewForeachFunc)
mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc)
noIconViewForeachFunc :: Maybe IconViewForeachFunc
noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures
wrap_IconViewForeachFunc :: Maybe (Ptr (FunPtr C_IconViewForeachFunc)) -> IconViewForeachFunc_WithClosures -> C_IconViewForeachFunc
type C_ListBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO (Ptr Widget)
type ListBoxCreateWidgetFunc = Object -> IO Widget
type ListBoxCreateWidgetFunc_WithClosures = Object -> Ptr () -> IO Widget
drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures
dynamic_ListBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ListBoxCreateWidgetFunc -> a -> Ptr () -> m Widget
genClosure_ListBoxCreateWidgetFunc :: MonadIO m => ListBoxCreateWidgetFunc -> m (GClosure C_ListBoxCreateWidgetFunc)
mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc)
noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc
noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures
wrap_ListBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_ListBoxCreateWidgetFunc)) -> ListBoxCreateWidgetFunc_WithClosures -> C_ListBoxCreateWidgetFunc
type C_ListBoxFilterFunc = Ptr ListBoxRow -> Ptr () -> IO CInt
type ListBoxFilterFunc = ListBoxRow -> IO Bool
type ListBoxFilterFunc_WithClosures = ListBoxRow -> Ptr () -> IO Bool
drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures
dynamic_ListBoxFilterFunc :: (HasCallStack, MonadIO m, IsListBoxRow a) => FunPtr C_ListBoxFilterFunc -> a -> Ptr () -> m Bool
genClosure_ListBoxFilterFunc :: MonadIO m => ListBoxFilterFunc -> m (GClosure C_ListBoxFilterFunc)
mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc)
noListBoxFilterFunc :: Maybe ListBoxFilterFunc
noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures
wrap_ListBoxFilterFunc :: Maybe (Ptr (FunPtr C_ListBoxFilterFunc)) -> ListBoxFilterFunc_WithClosures -> C_ListBoxFilterFunc
type C_ListBoxForeachFunc = Ptr ListBox -> Ptr ListBoxRow -> Ptr () -> IO ()
type ListBoxForeachFunc = ListBox -> ListBoxRow -> IO ()
type ListBoxForeachFunc_WithClosures = ListBox -> ListBoxRow -> Ptr () -> IO ()
drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures
dynamic_ListBoxForeachFunc :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => FunPtr C_ListBoxForeachFunc -> a -> b -> Ptr () -> m ()
genClosure_ListBoxForeachFunc :: MonadIO m => ListBoxForeachFunc -> m (GClosure C_ListBoxForeachFunc)
mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc)
noListBoxForeachFunc :: Maybe ListBoxForeachFunc
noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures
wrap_ListBoxForeachFunc :: Maybe (Ptr (FunPtr C_ListBoxForeachFunc)) -> ListBoxForeachFunc_WithClosures -> C_ListBoxForeachFunc
type C_ListBoxSortFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO Int32
type ListBoxSortFunc = ListBoxRow -> ListBoxRow -> IO Int32
type ListBoxSortFunc_WithClosures = ListBoxRow -> ListBoxRow -> Ptr () -> IO Int32
drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures
dynamic_ListBoxSortFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxSortFunc -> a -> b -> Ptr () -> m Int32
genClosure_ListBoxSortFunc :: MonadIO m => ListBoxSortFunc -> m (GClosure C_ListBoxSortFunc)
mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc)
noListBoxSortFunc :: Maybe ListBoxSortFunc
noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures
wrap_ListBoxSortFunc :: Maybe (Ptr (FunPtr C_ListBoxSortFunc)) -> ListBoxSortFunc_WithClosures -> C_ListBoxSortFunc
type C_ListBoxUpdateHeaderFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO ()
type ListBoxUpdateHeaderFunc = ListBoxRow -> Maybe ListBoxRow -> IO ()
type ListBoxUpdateHeaderFunc_WithClosures = ListBoxRow -> Maybe ListBoxRow -> Ptr () -> IO ()
drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures
dynamic_ListBoxUpdateHeaderFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxUpdateHeaderFunc -> a -> Maybe b -> Ptr () -> m ()
genClosure_ListBoxUpdateHeaderFunc :: MonadIO m => ListBoxUpdateHeaderFunc -> m (GClosure C_ListBoxUpdateHeaderFunc)
mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc)
noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc
noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures
wrap_ListBoxUpdateHeaderFunc :: Maybe (Ptr (FunPtr C_ListBoxUpdateHeaderFunc)) -> ListBoxUpdateHeaderFunc_WithClosures -> C_ListBoxUpdateHeaderFunc
type C_MapListModelMapFunc = Ptr Object -> Ptr () -> IO (Ptr Object)
type MapListModelMapFunc = Object -> IO Object
type MapListModelMapFunc_WithClosures = Object -> Ptr () -> IO Object
drop_closures_MapListModelMapFunc :: MapListModelMapFunc -> MapListModelMapFunc_WithClosures
dynamic_MapListModelMapFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_MapListModelMapFunc -> a -> Ptr () -> m Object
genClosure_MapListModelMapFunc :: MonadIO m => MapListModelMapFunc -> m (GClosure C_MapListModelMapFunc)
mk_MapListModelMapFunc :: C_MapListModelMapFunc -> IO (FunPtr C_MapListModelMapFunc)
noMapListModelMapFunc :: Maybe MapListModelMapFunc
noMapListModelMapFunc_WithClosures :: Maybe MapListModelMapFunc_WithClosures
wrap_MapListModelMapFunc :: Maybe (Ptr (FunPtr C_MapListModelMapFunc)) -> MapListModelMapFunc_WithClosures -> C_MapListModelMapFunc
type C_MenuButtonCreatePopupFunc = Ptr MenuButton -> Ptr () -> IO ()
type MenuButtonCreatePopupFunc = MenuButton -> IO ()
type MenuButtonCreatePopupFunc_WithClosures = MenuButton -> Ptr () -> IO ()
drop_closures_MenuButtonCreatePopupFunc :: MenuButtonCreatePopupFunc -> MenuButtonCreatePopupFunc_WithClosures
dynamic_MenuButtonCreatePopupFunc :: (HasCallStack, MonadIO m, IsMenuButton a) => FunPtr C_MenuButtonCreatePopupFunc -> a -> Ptr () -> m ()
genClosure_MenuButtonCreatePopupFunc :: MonadIO m => MenuButtonCreatePopupFunc -> m (GClosure C_MenuButtonCreatePopupFunc)
mk_MenuButtonCreatePopupFunc :: C_MenuButtonCreatePopupFunc -> IO (FunPtr C_MenuButtonCreatePopupFunc)
noMenuButtonCreatePopupFunc :: Maybe MenuButtonCreatePopupFunc
noMenuButtonCreatePopupFunc_WithClosures :: Maybe MenuButtonCreatePopupFunc_WithClosures
wrap_MenuButtonCreatePopupFunc :: Maybe (Ptr (FunPtr C_MenuButtonCreatePopupFunc)) -> MenuButtonCreatePopupFunc_WithClosures -> C_MenuButtonCreatePopupFunc
type C_PageSetupDoneFunc = Ptr PageSetup -> Ptr () -> IO ()
type PageSetupDoneFunc = PageSetup -> IO ()
type PageSetupDoneFunc_WithClosures = PageSetup -> Ptr () -> IO ()
drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures
dynamic_PageSetupDoneFunc :: (HasCallStack, MonadIO m, IsPageSetup a) => FunPtr C_PageSetupDoneFunc -> a -> Ptr () -> m ()
genClosure_PageSetupDoneFunc :: MonadIO m => PageSetupDoneFunc -> m (GClosure C_PageSetupDoneFunc)
mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc)
noPageSetupDoneFunc :: Maybe PageSetupDoneFunc
noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures
wrap_PageSetupDoneFunc :: Maybe (Ptr (FunPtr C_PageSetupDoneFunc)) -> PageSetupDoneFunc_WithClosures -> C_PageSetupDoneFunc
type C_PrintJobCompleteFunc = Ptr PrintJob -> Ptr () -> Ptr GError -> IO ()
type PrintJobCompleteFunc = PrintJob -> GError -> IO ()
type PrintJobCompleteFunc_WithClosures = PrintJob -> Ptr () -> GError -> IO ()
drop_closures_PrintJobCompleteFunc :: PrintJobCompleteFunc -> PrintJobCompleteFunc_WithClosures
dynamic_PrintJobCompleteFunc :: (HasCallStack, MonadIO m, IsPrintJob a) => FunPtr C_PrintJobCompleteFunc -> a -> Ptr () -> GError -> m ()
genClosure_PrintJobCompleteFunc :: MonadIO m => PrintJobCompleteFunc -> m (GClosure C_PrintJobCompleteFunc)
mk_PrintJobCompleteFunc :: C_PrintJobCompleteFunc -> IO (FunPtr C_PrintJobCompleteFunc)
noPrintJobCompleteFunc :: Maybe PrintJobCompleteFunc
noPrintJobCompleteFunc_WithClosures :: Maybe PrintJobCompleteFunc_WithClosures
wrap_PrintJobCompleteFunc :: Maybe (Ptr (FunPtr C_PrintJobCompleteFunc)) -> PrintJobCompleteFunc_WithClosures -> C_PrintJobCompleteFunc
type C_PrintSettingsFunc = CString -> CString -> Ptr () -> IO ()
type PrintSettingsFunc = Text -> Text -> IO ()
type PrintSettingsFunc_WithClosures = Text -> Text -> Ptr () -> IO ()
drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures
dynamic_PrintSettingsFunc :: (HasCallStack, MonadIO m) => FunPtr C_PrintSettingsFunc -> Text -> Text -> Ptr () -> m ()
genClosure_PrintSettingsFunc :: MonadIO m => PrintSettingsFunc -> m (GClosure C_PrintSettingsFunc)
mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc)
noPrintSettingsFunc :: Maybe PrintSettingsFunc
noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures
wrap_PrintSettingsFunc :: Maybe (Ptr (FunPtr C_PrintSettingsFunc)) -> PrintSettingsFunc_WithClosures -> C_PrintSettingsFunc
type C_PrinterFunc = Ptr Printer -> Ptr () -> IO CInt
type PrinterFunc = Printer -> IO Bool
type PrinterFunc_WithClosures = Printer -> Ptr () -> IO Bool
drop_closures_PrinterFunc :: PrinterFunc -> PrinterFunc_WithClosures
dynamic_PrinterFunc :: (HasCallStack, MonadIO m, IsPrinter a) => FunPtr C_PrinterFunc -> a -> Ptr () -> m Bool
genClosure_PrinterFunc :: MonadIO m => PrinterFunc -> m (GClosure C_PrinterFunc)
mk_PrinterFunc :: C_PrinterFunc -> IO (FunPtr C_PrinterFunc)
noPrinterFunc :: Maybe PrinterFunc
noPrinterFunc_WithClosures :: Maybe PrinterFunc_WithClosures
wrap_PrinterFunc :: Maybe (Ptr (FunPtr C_PrinterFunc)) -> PrinterFunc_WithClosures -> C_PrinterFunc
type C_ScaleFormatValueFunc = Ptr Scale -> CDouble -> Ptr () -> IO CString
type ScaleFormatValueFunc = Scale -> Double -> IO Text
type ScaleFormatValueFunc_WithClosures = Scale -> Double -> Ptr () -> IO Text
drop_closures_ScaleFormatValueFunc :: ScaleFormatValueFunc -> ScaleFormatValueFunc_WithClosures
dynamic_ScaleFormatValueFunc :: (HasCallStack, MonadIO m, IsScale a) => FunPtr C_ScaleFormatValueFunc -> a -> Double -> Ptr () -> m Text
genClosure_ScaleFormatValueFunc :: MonadIO m => ScaleFormatValueFunc -> m (GClosure C_ScaleFormatValueFunc)
mk_ScaleFormatValueFunc :: C_ScaleFormatValueFunc -> IO (FunPtr C_ScaleFormatValueFunc)
noScaleFormatValueFunc :: Maybe ScaleFormatValueFunc
noScaleFormatValueFunc_WithClosures :: Maybe ScaleFormatValueFunc_WithClosures
wrap_ScaleFormatValueFunc :: Maybe (Ptr (FunPtr C_ScaleFormatValueFunc)) -> ScaleFormatValueFunc_WithClosures -> C_ScaleFormatValueFunc
type C_ShortcutFunc = Ptr Widget -> Ptr GVariant -> Ptr () -> IO CInt
type ShortcutFunc = Widget -> Maybe GVariant -> IO Bool
type ShortcutFunc_WithClosures = Widget -> Maybe GVariant -> Ptr () -> IO Bool
drop_closures_ShortcutFunc :: ShortcutFunc -> ShortcutFunc_WithClosures
dynamic_ShortcutFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_ShortcutFunc -> a -> Maybe GVariant -> Ptr () -> m Bool
genClosure_ShortcutFunc :: MonadIO m => ShortcutFunc -> m (GClosure C_ShortcutFunc)
mk_ShortcutFunc :: C_ShortcutFunc -> IO (FunPtr C_ShortcutFunc)
noShortcutFunc :: Maybe ShortcutFunc
noShortcutFunc_WithClosures :: Maybe ShortcutFunc_WithClosures
wrap_ShortcutFunc :: Maybe (Ptr (FunPtr C_ShortcutFunc)) -> ShortcutFunc_WithClosures -> C_ShortcutFunc
type C_TextBufferCommitNotify = Ptr TextBuffer -> CUInt -> Word32 -> Word32 -> Ptr () -> IO ()
type TextBufferCommitNotify = TextBuffer -> [TextBufferNotifyFlags] -> Word32 -> Word32 -> IO ()
type TextBufferCommitNotify_WithClosures = TextBuffer -> [TextBufferNotifyFlags] -> Word32 -> Word32 -> Ptr () -> IO ()
drop_closures_TextBufferCommitNotify :: TextBufferCommitNotify -> TextBufferCommitNotify_WithClosures
dynamic_TextBufferCommitNotify :: (HasCallStack, MonadIO m, IsTextBuffer a) => FunPtr C_TextBufferCommitNotify -> a -> [TextBufferNotifyFlags] -> Word32 -> Word32 -> Ptr () -> m ()
genClosure_TextBufferCommitNotify :: MonadIO m => TextBufferCommitNotify -> m (GClosure C_TextBufferCommitNotify)
mk_TextBufferCommitNotify :: C_TextBufferCommitNotify -> IO (FunPtr C_TextBufferCommitNotify)
noTextBufferCommitNotify :: Maybe TextBufferCommitNotify
noTextBufferCommitNotify_WithClosures :: Maybe TextBufferCommitNotify_WithClosures
wrap_TextBufferCommitNotify :: Maybe (Ptr (FunPtr C_TextBufferCommitNotify)) -> TextBufferCommitNotify_WithClosures -> C_TextBufferCommitNotify
type C_TextCharPredicate = CInt -> Ptr () -> IO CInt
type TextCharPredicate = Char -> IO Bool
type TextCharPredicate_WithClosures = Char -> Ptr () -> IO Bool
drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures
dynamic_TextCharPredicate :: (HasCallStack, MonadIO m) => FunPtr C_TextCharPredicate -> Char -> Ptr () -> m Bool
genClosure_TextCharPredicate :: MonadIO m => TextCharPredicate -> m (GClosure C_TextCharPredicate)
mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate)
noTextCharPredicate :: Maybe TextCharPredicate
noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures
wrap_TextCharPredicate :: Maybe (Ptr (FunPtr C_TextCharPredicate)) -> TextCharPredicate_WithClosures -> C_TextCharPredicate
type C_TextTagTableForeach = Ptr TextTag -> Ptr () -> IO ()
type TextTagTableForeach = TextTag -> IO ()
type TextTagTableForeach_WithClosures = TextTag -> Ptr () -> IO ()
drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures
dynamic_TextTagTableForeach :: (HasCallStack, MonadIO m, IsTextTag a) => FunPtr C_TextTagTableForeach -> a -> Ptr () -> m ()
genClosure_TextTagTableForeach :: MonadIO m => TextTagTableForeach -> m (GClosure C_TextTagTableForeach)
mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)
noTextTagTableForeach :: Maybe TextTagTableForeach
noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures
wrap_TextTagTableForeach :: Maybe (Ptr (FunPtr C_TextTagTableForeach)) -> TextTagTableForeach_WithClosures -> C_TextTagTableForeach
type C_TickCallback = Ptr Widget -> Ptr FrameClock -> Ptr () -> IO CInt
type TickCallback = Widget -> FrameClock -> IO Bool
type TickCallback_WithClosures = Widget -> FrameClock -> Ptr () -> IO Bool
drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures
dynamic_TickCallback :: (HasCallStack, MonadIO m, IsWidget a, IsFrameClock b) => FunPtr C_TickCallback -> a -> b -> Ptr () -> m Bool
genClosure_TickCallback :: MonadIO m => TickCallback -> m (GClosure C_TickCallback)
mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback)
noTickCallback :: Maybe TickCallback
noTickCallback_WithClosures :: Maybe TickCallback_WithClosures
wrap_TickCallback :: Maybe (Ptr (FunPtr C_TickCallback)) -> TickCallback_WithClosures -> C_TickCallback
type C_TreeCellDataFunc = Ptr TreeViewColumn -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()
type TreeCellDataFunc = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> IO ()
type TreeCellDataFunc_WithClosures = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()
drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures
dynamic_TreeCellDataFunc :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b, IsTreeModel c) => FunPtr C_TreeCellDataFunc -> a -> b -> c -> TreeIter -> Ptr () -> m ()
genClosure_TreeCellDataFunc :: MonadIO m => TreeCellDataFunc -> m (GClosure C_TreeCellDataFunc)
mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)
noTreeCellDataFunc :: Maybe TreeCellDataFunc
noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures
wrap_TreeCellDataFunc :: Maybe (Ptr (FunPtr C_TreeCellDataFunc)) -> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc
type C_TreeIterCompareFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr TreeIter -> Ptr () -> IO Int32
type TreeIterCompareFunc = TreeModel -> TreeIter -> TreeIter -> IO Int32
type TreeIterCompareFunc_WithClosures = TreeModel -> TreeIter -> TreeIter -> Ptr () -> IO Int32
drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures
dynamic_TreeIterCompareFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeIterCompareFunc -> a -> TreeIter -> TreeIter -> Ptr () -> m Int32
genClosure_TreeIterCompareFunc :: MonadIO m => TreeIterCompareFunc -> m (GClosure C_TreeIterCompareFunc)
mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)
noTreeIterCompareFunc :: Maybe TreeIterCompareFunc
noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures
wrap_TreeIterCompareFunc :: Maybe (Ptr (FunPtr C_TreeIterCompareFunc)) -> TreeIterCompareFunc_WithClosures -> C_TreeIterCompareFunc
type C_TreeListModelCreateModelFunc = Ptr Object -> Ptr () -> IO (Ptr ListModel)
type TreeListModelCreateModelFunc = Object -> IO (Maybe ListModel)
type TreeListModelCreateModelFunc_WithClosures = Object -> Ptr () -> IO (Maybe ListModel)
drop_closures_TreeListModelCreateModelFunc :: TreeListModelCreateModelFunc -> TreeListModelCreateModelFunc_WithClosures
dynamic_TreeListModelCreateModelFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_TreeListModelCreateModelFunc -> a -> Ptr () -> m (Maybe ListModel)
genClosure_TreeListModelCreateModelFunc :: MonadIO m => TreeListModelCreateModelFunc -> m (GClosure C_TreeListModelCreateModelFunc)
mk_TreeListModelCreateModelFunc :: C_TreeListModelCreateModelFunc -> IO (FunPtr C_TreeListModelCreateModelFunc)
noTreeListModelCreateModelFunc :: Maybe TreeListModelCreateModelFunc
noTreeListModelCreateModelFunc_WithClosures :: Maybe TreeListModelCreateModelFunc_WithClosures
wrap_TreeListModelCreateModelFunc :: Maybe (Ptr (FunPtr C_TreeListModelCreateModelFunc)) -> TreeListModelCreateModelFunc_WithClosures -> C_TreeListModelCreateModelFunc
type C_TreeModelFilterModifyFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr GValue -> Int32 -> Ptr () -> IO ()
type TreeModelFilterModifyFunc = TreeModel -> TreeIter -> GValue -> Int32 -> IO ()
type TreeModelFilterModifyFunc_WithClosures = TreeModel -> TreeIter -> GValue -> Int32 -> Ptr () -> IO ()
drop_closures_TreeModelFilterModifyFunc :: TreeModelFilterModifyFunc -> TreeModelFilterModifyFunc_WithClosures
dynamic_TreeModelFilterModifyFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterModifyFunc -> a -> TreeIter -> GValue -> Int32 -> Ptr () -> m ()
genClosure_TreeModelFilterModifyFunc :: MonadIO m => TreeModelFilterModifyFunc -> m (GClosure C_TreeModelFilterModifyFunc)
mk_TreeModelFilterModifyFunc :: C_TreeModelFilterModifyFunc -> IO (FunPtr C_TreeModelFilterModifyFunc)
noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc
noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures
wrap_TreeModelFilterModifyFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterModifyFunc)) -> TreeModelFilterModifyFunc_WithClosures -> C_TreeModelFilterModifyFunc
type C_TreeModelFilterVisibleFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeModelFilterVisibleFunc = TreeModel -> TreeIter -> IO Bool
type TreeModelFilterVisibleFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures
dynamic_TreeModelFilterVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterVisibleFunc -> a -> TreeIter -> Ptr () -> m Bool
genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc)
mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)
noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc
noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures
wrap_TreeModelFilterVisibleFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc)) -> TreeModelFilterVisibleFunc_WithClosures -> C_TreeModelFilterVisibleFunc
type C_TreeModelForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeModelForeachFunc = TreeModel -> TreePath -> TreeIter -> IO Bool
type TreeModelForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures
dynamic_TreeModelForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m Bool
genClosure_TreeModelForeachFunc :: MonadIO m => TreeModelForeachFunc -> m (GClosure C_TreeModelForeachFunc)
mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)
noTreeModelForeachFunc :: Maybe TreeModelForeachFunc
noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures
wrap_TreeModelForeachFunc :: Maybe (Ptr (FunPtr C_TreeModelForeachFunc)) -> TreeModelForeachFunc_WithClosures -> C_TreeModelForeachFunc
type C_TreeSelectionForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()
type TreeSelectionForeachFunc = TreeModel -> TreePath -> TreeIter -> IO ()
type TreeSelectionForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO ()
drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures
dynamic_TreeSelectionForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeSelectionForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m ()
genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc)
mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)
noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc
noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures
wrap_TreeSelectionForeachFunc :: Maybe (Ptr (FunPtr C_TreeSelectionForeachFunc)) -> TreeSelectionForeachFunc_WithClosures -> C_TreeSelectionForeachFunc
type C_TreeSelectionFunc = Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt
type TreeSelectionFunc = TreeSelection -> TreeModel -> TreePath -> Bool -> IO Bool
type TreeSelectionFunc_WithClosures = TreeSelection -> TreeModel -> TreePath -> Bool -> Ptr () -> IO Bool
drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures
dynamic_TreeSelectionFunc :: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b) => FunPtr C_TreeSelectionFunc -> a -> b -> TreePath -> Bool -> Ptr () -> m Bool
genClosure_TreeSelectionFunc :: MonadIO m => TreeSelectionFunc -> m (GClosure C_TreeSelectionFunc)
mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)
noTreeSelectionFunc :: Maybe TreeSelectionFunc
noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures
wrap_TreeSelectionFunc :: Maybe (Ptr (FunPtr C_TreeSelectionFunc)) -> TreeSelectionFunc_WithClosures -> C_TreeSelectionFunc
type C_TreeViewColumnDropFunc = Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt
type TreeViewColumnDropFunc = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> IO Bool
type TreeViewColumnDropFunc_WithClosures = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> Ptr () -> IO Bool
drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures
dynamic_TreeViewColumnDropFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d) => FunPtr C_TreeViewColumnDropFunc -> a -> b -> c -> d -> Ptr () -> m Bool
genClosure_TreeViewColumnDropFunc :: MonadIO m => TreeViewColumnDropFunc -> m (GClosure C_TreeViewColumnDropFunc)
mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)
noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc
noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures
wrap_TreeViewColumnDropFunc :: Maybe (Ptr (FunPtr C_TreeViewColumnDropFunc)) -> TreeViewColumnDropFunc_WithClosures -> C_TreeViewColumnDropFunc
type C_TreeViewMappingFunc = Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()
type TreeViewMappingFunc = TreeView -> TreePath -> IO ()
type TreeViewMappingFunc_WithClosures = TreeView -> TreePath -> Ptr () -> IO ()
drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures
dynamic_TreeViewMappingFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeViewMappingFunc -> a -> TreePath -> Ptr () -> m ()
genClosure_TreeViewMappingFunc :: MonadIO m => TreeViewMappingFunc -> m (GClosure C_TreeViewMappingFunc)
mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)
noTreeViewMappingFunc :: Maybe TreeViewMappingFunc
noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures
wrap_TreeViewMappingFunc :: Maybe (Ptr (FunPtr C_TreeViewMappingFunc)) -> TreeViewMappingFunc_WithClosures -> C_TreeViewMappingFunc
type C_TreeViewRowSeparatorFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeViewRowSeparatorFunc = TreeModel -> TreeIter -> IO Bool
type TreeViewRowSeparatorFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures
dynamic_TreeViewRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewRowSeparatorFunc -> a -> TreeIter -> Ptr () -> m Bool
genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc)
mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)
noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc
noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures
wrap_TreeViewRowSeparatorFunc :: Maybe (Ptr (FunPtr C_TreeViewRowSeparatorFunc)) -> TreeViewRowSeparatorFunc_WithClosures -> C_TreeViewRowSeparatorFunc
type C_TreeViewSearchEqualFunc = Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeViewSearchEqualFunc = TreeModel -> Int32 -> Text -> TreeIter -> IO Bool
type TreeViewSearchEqualFunc_WithClosures = TreeModel -> Int32 -> Text -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures
dynamic_TreeViewSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewSearchEqualFunc -> a -> Int32 -> Text -> TreeIter -> Ptr () -> m Bool
genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc)
mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)
noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc
noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures
wrap_TreeViewSearchEqualFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchEqualFunc)) -> TreeViewSearchEqualFunc_WithClosures -> C_TreeViewSearchEqualFunc
type C_WidgetActionActivateFunc = Ptr Widget -> CString -> Ptr GVariant -> IO ()
type WidgetActionActivateFunc = Widget -> Text -> Maybe GVariant -> IO ()
dynamic_WidgetActionActivateFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetActionActivateFunc -> a -> Text -> Maybe GVariant -> m ()
genClosure_WidgetActionActivateFunc :: MonadIO m => WidgetActionActivateFunc -> m (GClosure C_WidgetActionActivateFunc)
mk_WidgetActionActivateFunc :: C_WidgetActionActivateFunc -> IO (FunPtr C_WidgetActionActivateFunc)
noWidgetActionActivateFunc :: Maybe WidgetActionActivateFunc
wrap_WidgetActionActivateFunc :: Maybe (Ptr (FunPtr C_WidgetActionActivateFunc)) -> WidgetActionActivateFunc -> C_WidgetActionActivateFunc
type C_WidgetClassComputeExpandFieldCallback = Ptr Widget -> CInt -> CInt -> IO ()
type WidgetClassComputeExpandFieldCallback = Widget -> Bool -> Bool -> IO ()
dynamic_WidgetClassComputeExpandFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassComputeExpandFieldCallback -> a -> Bool -> Bool -> m ()
genClosure_WidgetClassComputeExpandFieldCallback :: MonadIO m => WidgetClassComputeExpandFieldCallback -> m (GClosure C_WidgetClassComputeExpandFieldCallback)
mk_WidgetClassComputeExpandFieldCallback :: C_WidgetClassComputeExpandFieldCallback -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)
noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback
wrap_WidgetClassComputeExpandFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)) -> WidgetClassComputeExpandFieldCallback -> C_WidgetClassComputeExpandFieldCallback
type C_WidgetClassContainsFieldCallback = Ptr Widget -> CDouble -> CDouble -> IO CInt
type WidgetClassContainsFieldCallback = Widget -> Double -> Double -> IO Bool
dynamic_WidgetClassContainsFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassContainsFieldCallback -> a -> Double -> Double -> m Bool
genClosure_WidgetClassContainsFieldCallback :: MonadIO m => WidgetClassContainsFieldCallback -> m (GClosure C_WidgetClassContainsFieldCallback)
mk_WidgetClassContainsFieldCallback :: C_WidgetClassContainsFieldCallback -> IO (FunPtr C_WidgetClassContainsFieldCallback)
noWidgetClassContainsFieldCallback :: Maybe WidgetClassContainsFieldCallback
wrap_WidgetClassContainsFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassContainsFieldCallback)) -> WidgetClassContainsFieldCallback -> C_WidgetClassContainsFieldCallback
type C_WidgetClassCssChangedFieldCallback = Ptr Widget -> Ptr CssStyleChange -> IO ()
type WidgetClassCssChangedFieldCallback = Widget -> CssStyleChange -> IO ()
dynamic_WidgetClassCssChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCssChangedFieldCallback -> a -> CssStyleChange -> m ()
genClosure_WidgetClassCssChangedFieldCallback :: MonadIO m => WidgetClassCssChangedFieldCallback -> m (GClosure C_WidgetClassCssChangedFieldCallback)
mk_WidgetClassCssChangedFieldCallback :: C_WidgetClassCssChangedFieldCallback -> IO (FunPtr C_WidgetClassCssChangedFieldCallback)
noWidgetClassCssChangedFieldCallback :: Maybe WidgetClassCssChangedFieldCallback
wrap_WidgetClassCssChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)) -> WidgetClassCssChangedFieldCallback -> C_WidgetClassCssChangedFieldCallback
type C_WidgetClassDirectionChangedFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassDirectionChangedFieldCallback = Widget -> TextDirection -> IO ()
dynamic_WidgetClassDirectionChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDirectionChangedFieldCallback -> a -> TextDirection -> m ()
genClosure_WidgetClassDirectionChangedFieldCallback :: MonadIO m => WidgetClassDirectionChangedFieldCallback -> m (GClosure C_WidgetClassDirectionChangedFieldCallback)
mk_WidgetClassDirectionChangedFieldCallback :: C_WidgetClassDirectionChangedFieldCallback -> IO (FunPtr C_WidgetClassDirectionChangedFieldCallback)
noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback
wrap_WidgetClassDirectionChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDirectionChangedFieldCallback)) -> WidgetClassDirectionChangedFieldCallback -> C_WidgetClassDirectionChangedFieldCallback
type C_WidgetClassFocusFieldCallback = Ptr Widget -> CUInt -> IO CInt
type WidgetClassFocusFieldCallback = Widget -> DirectionType -> IO Bool
dynamic_WidgetClassFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusFieldCallback -> a -> DirectionType -> m Bool
genClosure_WidgetClassFocusFieldCallback :: MonadIO m => WidgetClassFocusFieldCallback -> m (GClosure C_WidgetClassFocusFieldCallback)
mk_WidgetClassFocusFieldCallback :: C_WidgetClassFocusFieldCallback -> IO (FunPtr C_WidgetClassFocusFieldCallback)
noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback
wrap_WidgetClassFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusFieldCallback)) -> WidgetClassFocusFieldCallback -> C_WidgetClassFocusFieldCallback
type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt
type WidgetClassGetRequestModeFieldCallback = Widget -> IO SizeRequestMode
dynamic_WidgetClassGetRequestModeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetRequestModeFieldCallback -> a -> m SizeRequestMode
genClosure_WidgetClassGetRequestModeFieldCallback :: MonadIO m => WidgetClassGetRequestModeFieldCallback -> m (GClosure C_WidgetClassGetRequestModeFieldCallback)
mk_WidgetClassGetRequestModeFieldCallback :: C_WidgetClassGetRequestModeFieldCallback -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)
noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback
wrap_WidgetClassGetRequestModeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)) -> WidgetClassGetRequestModeFieldCallback -> C_WidgetClassGetRequestModeFieldCallback
type C_WidgetClassGrabFocusFieldCallback = Ptr Widget -> IO CInt
type WidgetClassGrabFocusFieldCallback = Widget -> IO Bool
dynamic_WidgetClassGrabFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabFocusFieldCallback -> a -> m Bool
genClosure_WidgetClassGrabFocusFieldCallback :: MonadIO m => WidgetClassGrabFocusFieldCallback -> m (GClosure C_WidgetClassGrabFocusFieldCallback)
mk_WidgetClassGrabFocusFieldCallback :: C_WidgetClassGrabFocusFieldCallback -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)
noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback
wrap_WidgetClassGrabFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)) -> WidgetClassGrabFocusFieldCallback -> C_WidgetClassGrabFocusFieldCallback
type C_WidgetClassHideFieldCallback = Ptr Widget -> IO ()
type WidgetClassHideFieldCallback = Widget -> IO ()
dynamic_WidgetClassHideFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassHideFieldCallback -> a -> m ()
genClosure_WidgetClassHideFieldCallback :: MonadIO m => WidgetClassHideFieldCallback -> m (GClosure C_WidgetClassHideFieldCallback)
mk_WidgetClassHideFieldCallback :: C_WidgetClassHideFieldCallback -> IO (FunPtr C_WidgetClassHideFieldCallback)
noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback
wrap_WidgetClassHideFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHideFieldCallback)) -> WidgetClassHideFieldCallback -> C_WidgetClassHideFieldCallback
type C_WidgetClassKeynavFailedFieldCallback = Ptr Widget -> CUInt -> IO CInt
type WidgetClassKeynavFailedFieldCallback = Widget -> DirectionType -> IO Bool
dynamic_WidgetClassKeynavFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeynavFailedFieldCallback -> a -> DirectionType -> m Bool
genClosure_WidgetClassKeynavFailedFieldCallback :: MonadIO m => WidgetClassKeynavFailedFieldCallback -> m (GClosure C_WidgetClassKeynavFailedFieldCallback)
mk_WidgetClassKeynavFailedFieldCallback :: C_WidgetClassKeynavFailedFieldCallback -> IO (FunPtr C_WidgetClassKeynavFailedFieldCallback)
noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback
wrap_WidgetClassKeynavFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeynavFailedFieldCallback)) -> WidgetClassKeynavFailedFieldCallback -> C_WidgetClassKeynavFailedFieldCallback
type C_WidgetClassMapFieldCallback = Ptr Widget -> IO ()
type WidgetClassMapFieldCallback = Widget -> IO ()
dynamic_WidgetClassMapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapFieldCallback -> a -> m ()
genClosure_WidgetClassMapFieldCallback :: MonadIO m => WidgetClassMapFieldCallback -> m (GClosure C_WidgetClassMapFieldCallback)
mk_WidgetClassMapFieldCallback :: C_WidgetClassMapFieldCallback -> IO (FunPtr C_WidgetClassMapFieldCallback)
noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback
wrap_WidgetClassMapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapFieldCallback)) -> WidgetClassMapFieldCallback -> C_WidgetClassMapFieldCallback
type C_WidgetClassMeasureFieldCallback = Ptr Widget -> CUInt -> Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
type WidgetClassMeasureFieldCallback = Widget -> Orientation -> Int32 -> IO (Int32, Int32, Int32, Int32)
dynamic_WidgetClassMeasureFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMeasureFieldCallback -> a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)
genClosure_WidgetClassMeasureFieldCallback :: MonadIO m => WidgetClassMeasureFieldCallback -> m (GClosure C_WidgetClassMeasureFieldCallback)
mk_WidgetClassMeasureFieldCallback :: C_WidgetClassMeasureFieldCallback -> IO (FunPtr C_WidgetClassMeasureFieldCallback)
noWidgetClassMeasureFieldCallback :: Maybe WidgetClassMeasureFieldCallback
wrap_WidgetClassMeasureFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMeasureFieldCallback)) -> WidgetClassMeasureFieldCallback -> C_WidgetClassMeasureFieldCallback
type C_WidgetClassMnemonicActivateFieldCallback = Ptr Widget -> CInt -> IO CInt
type WidgetClassMnemonicActivateFieldCallback = Widget -> Bool -> IO Bool
dynamic_WidgetClassMnemonicActivateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMnemonicActivateFieldCallback -> a -> Bool -> m Bool
genClosure_WidgetClassMnemonicActivateFieldCallback :: MonadIO m => WidgetClassMnemonicActivateFieldCallback -> m (GClosure C_WidgetClassMnemonicActivateFieldCallback)
mk_WidgetClassMnemonicActivateFieldCallback :: C_WidgetClassMnemonicActivateFieldCallback -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback
wrap_WidgetClassMnemonicActivateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)) -> WidgetClassMnemonicActivateFieldCallback -> C_WidgetClassMnemonicActivateFieldCallback
type C_WidgetClassMoveFocusFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassMoveFocusFieldCallback = Widget -> DirectionType -> IO ()
dynamic_WidgetClassMoveFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMoveFocusFieldCallback -> a -> DirectionType -> m ()
genClosure_WidgetClassMoveFocusFieldCallback :: MonadIO m => WidgetClassMoveFocusFieldCallback -> m (GClosure C_WidgetClassMoveFocusFieldCallback)
mk_WidgetClassMoveFocusFieldCallback :: C_WidgetClassMoveFocusFieldCallback -> IO (FunPtr C_WidgetClassMoveFocusFieldCallback)
noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback
wrap_WidgetClassMoveFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMoveFocusFieldCallback)) -> WidgetClassMoveFocusFieldCallback -> C_WidgetClassMoveFocusFieldCallback
type C_WidgetClassQueryTooltipFieldCallback = Ptr Widget -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> IO CInt
type WidgetClassQueryTooltipFieldCallback = Widget -> Int32 -> Int32 -> Bool -> Tooltip -> IO Bool
dynamic_WidgetClassQueryTooltipFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsTooltip b) => FunPtr C_WidgetClassQueryTooltipFieldCallback -> a -> Int32 -> Int32 -> Bool -> b -> m Bool
genClosure_WidgetClassQueryTooltipFieldCallback :: MonadIO m => WidgetClassQueryTooltipFieldCallback -> m (GClosure C_WidgetClassQueryTooltipFieldCallback)
mk_WidgetClassQueryTooltipFieldCallback :: C_WidgetClassQueryTooltipFieldCallback -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)
noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback
wrap_WidgetClassQueryTooltipFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)) -> WidgetClassQueryTooltipFieldCallback -> C_WidgetClassQueryTooltipFieldCallback
type C_WidgetClassRealizeFieldCallback = Ptr Widget -> IO ()
type WidgetClassRealizeFieldCallback = Widget -> IO ()
dynamic_WidgetClassRealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassRealizeFieldCallback -> a -> m ()
genClosure_WidgetClassRealizeFieldCallback :: MonadIO m => WidgetClassRealizeFieldCallback -> m (GClosure C_WidgetClassRealizeFieldCallback)
mk_WidgetClassRealizeFieldCallback :: C_WidgetClassRealizeFieldCallback -> IO (FunPtr C_WidgetClassRealizeFieldCallback)
noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback
wrap_WidgetClassRealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRealizeFieldCallback)) -> WidgetClassRealizeFieldCallback -> C_WidgetClassRealizeFieldCallback
type C_WidgetClassRootFieldCallback = Ptr Widget -> IO ()
type WidgetClassRootFieldCallback = Widget -> IO ()
dynamic_WidgetClassRootFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassRootFieldCallback -> a -> m ()
genClosure_WidgetClassRootFieldCallback :: MonadIO m => WidgetClassRootFieldCallback -> m (GClosure C_WidgetClassRootFieldCallback)
mk_WidgetClassRootFieldCallback :: C_WidgetClassRootFieldCallback -> IO (FunPtr C_WidgetClassRootFieldCallback)
noWidgetClassRootFieldCallback :: Maybe WidgetClassRootFieldCallback
wrap_WidgetClassRootFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRootFieldCallback)) -> WidgetClassRootFieldCallback -> C_WidgetClassRootFieldCallback
type C_WidgetClassSetFocusChildFieldCallback = Ptr Widget -> Ptr Widget -> IO ()
type WidgetClassSetFocusChildFieldCallback = Widget -> Maybe Widget -> IO ()
dynamic_WidgetClassSetFocusChildFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassSetFocusChildFieldCallback -> a -> Maybe b -> m ()
genClosure_WidgetClassSetFocusChildFieldCallback :: MonadIO m => WidgetClassSetFocusChildFieldCallback -> m (GClosure C_WidgetClassSetFocusChildFieldCallback)
mk_WidgetClassSetFocusChildFieldCallback :: C_WidgetClassSetFocusChildFieldCallback -> IO (FunPtr C_WidgetClassSetFocusChildFieldCallback)
noWidgetClassSetFocusChildFieldCallback :: Maybe WidgetClassSetFocusChildFieldCallback
wrap_WidgetClassSetFocusChildFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)) -> WidgetClassSetFocusChildFieldCallback -> C_WidgetClassSetFocusChildFieldCallback
type C_WidgetClassShowFieldCallback = Ptr Widget -> IO ()
type WidgetClassShowFieldCallback = Widget -> IO ()
dynamic_WidgetClassShowFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
genClosure_WidgetClassShowFieldCallback :: MonadIO m => WidgetClassShowFieldCallback -> m (GClosure C_WidgetClassShowFieldCallback)
mk_WidgetClassShowFieldCallback :: C_WidgetClassShowFieldCallback -> IO (FunPtr C_WidgetClassShowFieldCallback)
noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback
wrap_WidgetClassShowFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowFieldCallback)) -> WidgetClassShowFieldCallback -> C_WidgetClassShowFieldCallback
type C_WidgetClassSizeAllocateFieldCallback = Ptr Widget -> Int32 -> Int32 -> Int32 -> IO ()
type WidgetClassSizeAllocateFieldCallback = Widget -> Int32 -> Int32 -> Int32 -> IO ()
dynamic_WidgetClassSizeAllocateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSizeAllocateFieldCallback -> a -> Int32 -> Int32 -> Int32 -> m ()
genClosure_WidgetClassSizeAllocateFieldCallback :: MonadIO m => WidgetClassSizeAllocateFieldCallback -> m (GClosure C_WidgetClassSizeAllocateFieldCallback)
mk_WidgetClassSizeAllocateFieldCallback :: C_WidgetClassSizeAllocateFieldCallback -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)
noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback
wrap_WidgetClassSizeAllocateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)) -> WidgetClassSizeAllocateFieldCallback -> C_WidgetClassSizeAllocateFieldCallback
type C_WidgetClassSnapshotFieldCallback = Ptr Widget -> Ptr Snapshot -> IO ()
type WidgetClassSnapshotFieldCallback = Widget -> Snapshot -> IO ()
dynamic_WidgetClassSnapshotFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsSnapshot b) => FunPtr C_WidgetClassSnapshotFieldCallback -> a -> b -> m ()
genClosure_WidgetClassSnapshotFieldCallback :: MonadIO m => WidgetClassSnapshotFieldCallback -> m (GClosure C_WidgetClassSnapshotFieldCallback)
mk_WidgetClassSnapshotFieldCallback :: C_WidgetClassSnapshotFieldCallback -> IO (FunPtr C_WidgetClassSnapshotFieldCallback)
noWidgetClassSnapshotFieldCallback :: Maybe WidgetClassSnapshotFieldCallback
wrap_WidgetClassSnapshotFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)) -> WidgetClassSnapshotFieldCallback -> C_WidgetClassSnapshotFieldCallback
type C_WidgetClassStateFlagsChangedFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassStateFlagsChangedFieldCallback = Widget -> [StateFlags] -> IO ()
dynamic_WidgetClassStateFlagsChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> a -> [StateFlags] -> m ()
genClosure_WidgetClassStateFlagsChangedFieldCallback :: MonadIO m => WidgetClassStateFlagsChangedFieldCallback -> m (GClosure C_WidgetClassStateFlagsChangedFieldCallback)
mk_WidgetClassStateFlagsChangedFieldCallback :: C_WidgetClassStateFlagsChangedFieldCallback -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback
wrap_WidgetClassStateFlagsChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)) -> WidgetClassStateFlagsChangedFieldCallback -> C_WidgetClassStateFlagsChangedFieldCallback
type C_WidgetClassSystemSettingChangedFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassSystemSettingChangedFieldCallback = Widget -> SystemSetting -> IO ()
dynamic_WidgetClassSystemSettingChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSystemSettingChangedFieldCallback -> a -> SystemSetting -> m ()
genClosure_WidgetClassSystemSettingChangedFieldCallback :: MonadIO m => WidgetClassSystemSettingChangedFieldCallback -> m (GClosure C_WidgetClassSystemSettingChangedFieldCallback)
mk_WidgetClassSystemSettingChangedFieldCallback :: C_WidgetClassSystemSettingChangedFieldCallback -> IO (FunPtr C_WidgetClassSystemSettingChangedFieldCallback)
noWidgetClassSystemSettingChangedFieldCallback :: Maybe WidgetClassSystemSettingChangedFieldCallback
wrap_WidgetClassSystemSettingChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSystemSettingChangedFieldCallback)) -> WidgetClassSystemSettingChangedFieldCallback -> C_WidgetClassSystemSettingChangedFieldCallback
type C_WidgetClassUnmapFieldCallback = Ptr Widget -> IO ()
type WidgetClassUnmapFieldCallback = Widget -> IO ()
dynamic_WidgetClassUnmapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapFieldCallback -> a -> m ()
genClosure_WidgetClassUnmapFieldCallback :: MonadIO m => WidgetClassUnmapFieldCallback -> m (GClosure C_WidgetClassUnmapFieldCallback)
mk_WidgetClassUnmapFieldCallback :: C_WidgetClassUnmapFieldCallback -> IO (FunPtr C_WidgetClassUnmapFieldCallback)
noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback
wrap_WidgetClassUnmapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapFieldCallback)) -> WidgetClassUnmapFieldCallback -> C_WidgetClassUnmapFieldCallback
type C_WidgetClassUnrealizeFieldCallback = Ptr Widget -> IO ()
type WidgetClassUnrealizeFieldCallback = Widget -> IO ()
dynamic_WidgetClassUnrealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnrealizeFieldCallback -> a -> m ()
genClosure_WidgetClassUnrealizeFieldCallback :: MonadIO m => WidgetClassUnrealizeFieldCallback -> m (GClosure C_WidgetClassUnrealizeFieldCallback)
mk_WidgetClassUnrealizeFieldCallback :: C_WidgetClassUnrealizeFieldCallback -> IO (FunPtr C_WidgetClassUnrealizeFieldCallback)
noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback
wrap_WidgetClassUnrealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrealizeFieldCallback)) -> WidgetClassUnrealizeFieldCallback -> C_WidgetClassUnrealizeFieldCallback
type C_WidgetClassUnrootFieldCallback = Ptr Widget -> IO ()
type WidgetClassUnrootFieldCallback = Widget -> IO ()
dynamic_WidgetClassUnrootFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnrootFieldCallback -> a -> m ()
genClosure_WidgetClassUnrootFieldCallback :: MonadIO m => WidgetClassUnrootFieldCallback -> m (GClosure C_WidgetClassUnrootFieldCallback)
mk_WidgetClassUnrootFieldCallback :: C_WidgetClassUnrootFieldCallback -> IO (FunPtr C_WidgetClassUnrootFieldCallback)
noWidgetClassUnrootFieldCallback :: Maybe WidgetClassUnrootFieldCallback
wrap_WidgetClassUnrootFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrootFieldCallback)) -> WidgetClassUnrootFieldCallback -> C_WidgetClassUnrootFieldCallback

Signals

AssistantPageFunc

type AssistantPageFunc Source #

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

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

noAssistantPageFunc :: Maybe AssistantPageFunc Source #

A convenience synonym for Nothing :: Maybe AssistantPageFunc.

noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe AssistantPageFunc_WithClosures.

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

Wrap a AssistantPageFunc into 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.

drop_closures_BuildableParserEndElementFieldCallback :: BuildableParserEndElementFieldCallback -> BuildableParserEndElementFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BuildableParserEndElementFieldCallback Source #

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

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

noBuildableParserEndElementFieldCallback :: Maybe BuildableParserEndElementFieldCallback Source #

A convenience synonym for Nothing :: Maybe BuildableParserEndElementFieldCallback.

noBuildableParserEndElementFieldCallback_WithClosures :: Maybe BuildableParserEndElementFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BuildableParserEndElementFieldCallback_WithClosures.

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.

drop_closures_BuildableParserErrorFieldCallback :: BuildableParserErrorFieldCallback -> BuildableParserErrorFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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.

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

Wrap the callback into a GClosure.

mk_BuildableParserErrorFieldCallback :: C_BuildableParserErrorFieldCallback -> IO (FunPtr C_BuildableParserErrorFieldCallback) Source #

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

noBuildableParserErrorFieldCallback :: Maybe BuildableParserErrorFieldCallback Source #

A convenience synonym for Nothing :: Maybe BuildableParserErrorFieldCallback.

noBuildableParserErrorFieldCallback_WithClosures :: Maybe BuildableParserErrorFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BuildableParserErrorFieldCallback_WithClosures.

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

Wrap a BuildableParserErrorFieldCallback into a C_BuildableParserErrorFieldCallback.

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.

drop_closures_BuildableParserStartElementFieldCallback :: BuildableParserStartElementFieldCallback -> BuildableParserStartElementFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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.

mk_BuildableParserStartElementFieldCallback :: C_BuildableParserStartElementFieldCallback -> IO (FunPtr C_BuildableParserStartElementFieldCallback) Source #

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

noBuildableParserStartElementFieldCallback :: Maybe BuildableParserStartElementFieldCallback Source #

A convenience synonym for Nothing :: Maybe BuildableParserStartElementFieldCallback.

noBuildableParserStartElementFieldCallback_WithClosures :: Maybe BuildableParserStartElementFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BuildableParserStartElementFieldCallback_WithClosures.

BuildableParserTextFieldCallback

type BuildableParserTextFieldCallback Source #

Arguments

= BuildableParseContext
-> Text
-> CSize
-> IO ()	(Can throw `GError`)

No description available in the introspection data.

type BuildableParserTextFieldCallback_WithClosures Source #

Arguments

= BuildableParseContext
-> Text
-> CSize
-> Ptr ()
-> IO ()	(Can throw `GError`)

No description available in the introspection data.

type C_BuildableParserTextFieldCallback = Ptr BuildableParseContext -> CString -> CSize -> Ptr () -> Ptr (Ptr GError) -> IO () Source #

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

drop_closures_BuildableParserTextFieldCallback :: BuildableParserTextFieldCallback -> BuildableParserTextFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BuildableParserTextFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_BuildableParserTextFieldCallback
-> BuildableParseContext
-> Text
-> CSize
-> 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) Source #

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

noBuildableParserTextFieldCallback :: Maybe BuildableParserTextFieldCallback Source #

A convenience synonym for Nothing :: Maybe BuildableParserTextFieldCallback.

noBuildableParserTextFieldCallback_WithClosures :: Maybe BuildableParserTextFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BuildableParserTextFieldCallback_WithClosures.

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.

Deprecated: (Since version 4.20)There is no replacement

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

noCellAllocCallback :: Maybe CellAllocCallback Source #

A convenience synonym for Nothing :: Maybe CellAllocCallback.

noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe CellAllocCallback_WithClosures.

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

Wrap a CellAllocCallback into 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.

Deprecated: (Since version 4.20)There is no replacement

The type of the callback functions used for iterating over the cell renderers of a GtkCellArea, 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 GtkCellArea, 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.

noCellCallback :: Maybe CellCallback Source #

A convenience synonym for Nothing :: Maybe CellCallback.

noCellCallback_WithClosures :: Maybe CellCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe CellCallback_WithClosures.

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

Wrap a CellCallback into 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 `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 ()

Deprecated: (Since version 4.20)There is no replacement

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

type CellLayoutDataFunc_WithClosures Source #

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

noCellLayoutDataFunc :: Maybe CellLayoutDataFunc Source #

A convenience synonym for Nothing :: Maybe CellLayoutDataFunc.

noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe CellLayoutDataFunc_WithClosures.

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

Wrap a CellLayoutDataFunc into 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 GtkCustomLayout 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.

noCustomAllocateFunc :: Maybe CustomAllocateFunc Source #

A convenience synonym for Nothing :: Maybe CustomAllocateFunc.

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

Wrap a CustomAllocateFunc into 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.

noCustomFilterFunc :: Maybe CustomFilterFunc Source #

A convenience synonym for Nothing :: Maybe CustomFilterFunc.

noCustomFilterFunc_WithClosures :: Maybe CustomFilterFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe CustomFilterFunc_WithClosures.

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

Wrap a CustomFilterFunc into 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 GtkCustomLayout 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.

noCustomMeasureFunc :: Maybe CustomMeasureFunc Source #

A convenience synonym for Nothing :: Maybe CustomMeasureFunc.

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

Wrap a CustomMeasureFunc into 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.

noCustomRequestModeFunc :: Maybe CustomRequestModeFunc Source #

A convenience synonym for Nothing :: Maybe CustomRequestModeFunc.

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

Wrap a CustomRequestModeFunc into 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 `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 Source #

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

A simple wrapper that ignores the closure arguments.

dynamic_DrawingAreaDrawFunc Source #

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

noDrawingAreaDrawFunc :: Maybe DrawingAreaDrawFunc Source #

A convenience synonym for Nothing :: Maybe DrawingAreaDrawFunc.

noDrawingAreaDrawFunc_WithClosures :: Maybe DrawingAreaDrawFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DrawingAreaDrawFunc_WithClosures.

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

Wrap a DrawingAreaDrawFunc into 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 `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`

Deprecated: (Since version 4.20)There is no replacement

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

A simple wrapper that ignores the closure arguments.

dynamic_EntryCompletionMatchFunc Source #

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

Wrap the callback into a GClosure.

mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc) Source #

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

noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc Source #

A convenience synonym for Nothing :: Maybe EntryCompletionMatchFunc.

noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe EntryCompletionMatchFunc_WithClosures.

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

Wrap a EntryCompletionMatchFunc into a C_EntryCompletionMatchFunc.

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.

noExpressionNotify :: Maybe ExpressionNotify Source #

A convenience synonym for Nothing :: Maybe ExpressionNotify.

noExpressionNotify_WithClosures :: Maybe ExpressionNotify_WithClosures Source #

A convenience synonym for Nothing :: Maybe ExpressionNotify_WithClosures.

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

Wrap a ExpressionNotify into 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 `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 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 `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 Source #

A simple wrapper that ignores the closure arguments.

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

Wrap the callback into a GClosure.

mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc) Source #

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

noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc Source #

A convenience synonym for Nothing :: Maybe FlowBoxCreateWidgetFunc.

noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe FlowBoxCreateWidgetFunc_WithClosures.

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

Wrap a FlowBoxCreateWidgetFunc into a C_FlowBoxCreateWidgetFunc.

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

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

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxFilterFunc Source #

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

noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc Source #

A convenience synonym for Nothing :: Maybe FlowBoxFilterFunc.

noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe FlowBoxFilterFunc_WithClosures.

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

Wrap a FlowBoxFilterFunc into 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 `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 Source #

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

noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc Source #

A convenience synonym for Nothing :: Maybe FlowBoxForeachFunc.

noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe FlowBoxForeachFunc_WithClosures.

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

Wrap a FlowBoxForeachFunc into 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 they 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 they 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 they 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.

noFlowBoxSortFunc :: Maybe FlowBoxSortFunc Source #

A convenience synonym for Nothing :: Maybe FlowBoxSortFunc.

noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe FlowBoxSortFunc_WithClosures.

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

Wrap a FlowBoxSortFunc into 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 `PangoFontFamily`
-> FontFace	`face`: a `PangoFontFace` belonging to `family`
-> IO Bool	Returns: `True` if the font should be displayed

Deprecated: (Since version 4.20)There is no replacement

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

See fontChooserSetFilterFunc.

type FontFilterFunc_WithClosures Source #

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

noFontFilterFunc :: Maybe FontFilterFunc Source #

A convenience synonym for Nothing :: Maybe FontFilterFunc.

noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe FontFilterFunc_WithClosures.

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

Wrap a FontFilterFunc into 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 `GtkIconView`
-> TreePath	`path`: The `GtkTreePath` of a selected row
-> IO ()

Deprecated: (Since version 4.20)There is no replacement.

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

A simple wrapper that ignores the closure arguments.

dynamic_IconViewForeachFunc Source #

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

noIconViewForeachFunc :: Maybe IconViewForeachFunc Source #

A convenience synonym for Nothing :: Maybe IconViewForeachFunc.

noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe IconViewForeachFunc_WithClosures.

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

Wrap a IconViewForeachFunc into 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 `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 Source #

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

A simple wrapper that ignores the closure arguments.

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

Wrap the callback into a GClosure.

mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc) Source #

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

noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc Source #

A convenience synonym for Nothing :: Maybe ListBoxCreateWidgetFunc.

noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ListBoxCreateWidgetFunc_WithClosures.

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

Wrap a ListBoxCreateWidgetFunc into a C_ListBoxCreateWidgetFunc.

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.

noListBoxFilterFunc :: Maybe ListBoxFilterFunc Source #

A convenience synonym for Nothing :: Maybe ListBoxFilterFunc.

noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ListBoxFilterFunc_WithClosures.

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

Wrap a ListBoxFilterFunc into 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 `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 Source #

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

noListBoxForeachFunc :: Maybe ListBoxForeachFunc Source #

A convenience synonym for Nothing :: Maybe ListBoxForeachFunc.

noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ListBoxForeachFunc_WithClosures.

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

Wrap a ListBoxForeachFunc into 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.

noListBoxSortFunc :: Maybe ListBoxSortFunc Source #

A convenience synonym for Nothing :: Maybe ListBoxSortFunc.

noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ListBoxSortFunc_WithClosures.

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

Wrap a ListBoxSortFunc into 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.

drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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.

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

Wrap the callback into a GClosure.

mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc) Source #

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

noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc Source #

A convenience synonym for Nothing :: Maybe ListBoxUpdateHeaderFunc.

noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ListBoxUpdateHeaderFunc_WithClosures.

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

Wrap a ListBoxUpdateHeaderFunc into a C_ListBoxUpdateHeaderFunc.

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

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

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

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.

noMapListModelMapFunc :: Maybe MapListModelMapFunc Source #

A convenience synonym for Nothing :: Maybe MapListModelMapFunc.

noMapListModelMapFunc_WithClosures :: Maybe MapListModelMapFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe MapListModelMapFunc_WithClosures.

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

Wrap a MapListModelMapFunc into 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 `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 Source #

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

A simple wrapper that ignores the closure arguments.

dynamic_MenuButtonCreatePopupFunc Source #

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

Wrap the callback into a GClosure.

mk_MenuButtonCreatePopupFunc :: C_MenuButtonCreatePopupFunc -> IO (FunPtr C_MenuButtonCreatePopupFunc) Source #

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

noMenuButtonCreatePopupFunc :: Maybe MenuButtonCreatePopupFunc Source #

A convenience synonym for Nothing :: Maybe MenuButtonCreatePopupFunc.

noMenuButtonCreatePopupFunc_WithClosures :: Maybe MenuButtonCreatePopupFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe MenuButtonCreatePopupFunc_WithClosures.

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

Wrap a MenuButtonCreatePopupFunc into a C_MenuButtonCreatePopupFunc.

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

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

A simple wrapper that ignores the closure arguments.

dynamic_PageSetupDoneFunc Source #

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

noPageSetupDoneFunc :: Maybe PageSetupDoneFunc Source #

A convenience synonym for Nothing :: Maybe PageSetupDoneFunc.

noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe PageSetupDoneFunc_WithClosures.

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

Wrap a PageSetupDoneFunc into a C_PageSetupDoneFunc.

PrintJobCompleteFunc

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

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

type PrintJobCompleteFunc Source #

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

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

A simple wrapper that ignores the closure arguments.

dynamic_PrintJobCompleteFunc Source #

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

Wrap the callback into a GClosure.

mk_PrintJobCompleteFunc :: C_PrintJobCompleteFunc -> IO (FunPtr C_PrintJobCompleteFunc) Source #

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

noPrintJobCompleteFunc :: Maybe PrintJobCompleteFunc Source #

A convenience synonym for Nothing :: Maybe PrintJobCompleteFunc.

noPrintJobCompleteFunc_WithClosures :: Maybe PrintJobCompleteFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe PrintJobCompleteFunc_WithClosures.

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

Wrap a PrintJobCompleteFunc into a C_PrintJobCompleteFunc.

PrintSettingsFunc

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

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

type PrintSettingsFunc Source #

Arguments

= Text	`key`: the setting key
-> Text	`value`: the setting value
-> IO ()

Function called by printSettingsForeach on every key/value pair inside a PrintSettings.

type PrintSettingsFunc_WithClosures Source #

Arguments

= Text	`key`: the setting key
-> Text	`value`: the setting value
-> Ptr ()	`userData`: The user data provided with the function
-> IO ()

Function called by printSettingsForeach on every key/value pair inside a PrintSettings.

drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_PrintSettingsFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_PrintSettingsFunc
-> Text	`key`: the setting key
-> Text	`value`: the setting value
-> Ptr ()	`userData`: The user data provided with the function
-> 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) 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.

noPrintSettingsFunc :: Maybe PrintSettingsFunc Source #

A convenience synonym for Nothing :: Maybe PrintSettingsFunc.

noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe PrintSettingsFunc_WithClosures.

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

Wrap a PrintSettingsFunc into a C_PrintSettingsFunc.

PrinterFunc

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

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

type PrinterFunc Source #

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

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

A simple wrapper that ignores the closure arguments.

dynamic_PrinterFunc Source #

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

Wrap the callback into a GClosure.

mk_PrinterFunc :: C_PrinterFunc -> IO (FunPtr C_PrinterFunc) Source #

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

noPrinterFunc :: Maybe PrinterFunc Source #

A convenience synonym for Nothing :: Maybe PrinterFunc.

noPrinterFunc_WithClosures :: Maybe PrinterFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe PrinterFunc_WithClosures.

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

Wrap a PrinterFunc into a C_PrinterFunc.

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 `GtkScale`
-> Double	`value`: The numeric value to format
-> IO Text	Returns: A newly allocated string describing a textual representation of the given numerical value.

Function that formats the value of a scale.

See scaleSetFormatValueFunc.

type ScaleFormatValueFunc_WithClosures Source #

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.

Function that formats the value of a scale.

See scaleSetFormatValueFunc.

drop_closures_ScaleFormatValueFunc :: ScaleFormatValueFunc -> ScaleFormatValueFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ScaleFormatValueFunc Source #

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

noScaleFormatValueFunc :: Maybe ScaleFormatValueFunc Source #

A convenience synonym for Nothing :: Maybe ScaleFormatValueFunc.

noScaleFormatValueFunc_WithClosures :: Maybe ScaleFormatValueFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ScaleFormatValueFunc_WithClosures.

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

Wrap a ScaleFormatValueFunc into 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	Returns: true if the action was successful

Type 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	Returns: true if the action was successful

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

noShortcutFunc :: Maybe ShortcutFunc Source #

A convenience synonym for Nothing :: Maybe ShortcutFunc.

noShortcutFunc_WithClosures :: Maybe ShortcutFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ShortcutFunc_WithClosures.

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

Wrap a ShortcutFunc into a C_ShortcutFunc.

TextBufferCommitNotify

type C_TextBufferCommitNotify = Ptr TextBuffer -> CUInt -> Word32 -> Word32 -> Ptr () -> IO () Source #

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

type TextBufferCommitNotify Source #

Arguments

= TextBuffer	`buffer`: the text buffer being notified
-> [TextBufferNotifyFlags]	`flags`: the type of commit notification
-> Word32	`position`: the position of the text operation
-> Word32	`length`: the length of the text operation in characters
-> IO ()

A notification callback used by textBufferAddCommitNotify.

You may not modify the TextBuffer from a [callbackgtk.TextBufferCommitNotify] callback and that is enforced by the TextBuffer API.

callbackgtk.TextBufferCommitNotify: may be used to be notified about changes to the underlying buffer right before-or-after the changes are committed to the underlying B-Tree. This is useful if you want to observe changes to the buffer without other signal handlers potentially modifying state on the way to the default signal handler.

When flags is GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT, position is set to the offset in characters from the start of the buffer where the insertion will occur. length is set to the number of characters to be inserted. You may not yet retrieve the text until it has been inserted. You may access the text from GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT using textBufferGetSlice.

When flags is GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT, position is set to offset in characters where the insertion occurred and length is set to the number of characters inserted.

When flags is GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE, position is set to offset in characters where the deletion will occur and length is set to the number of characters that will be removed. You may still retrieve the text from this handler using position and length.

When flags is GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE, length is set to zero to denote that the delete-range has already been committed to the underlying B-Tree. You may no longer retrieve the text that has been deleted from the TextBuffer.

Since: 4.16

type TextBufferCommitNotify_WithClosures Source #

Arguments

= TextBuffer	`buffer`: the text buffer being notified
-> [TextBufferNotifyFlags]	`flags`: the type of commit notification
-> Word32	`position`: the position of the text operation
-> Word32	`length`: the length of the text operation in characters
-> Ptr ()	`userData`: user data passed to the callback
-> IO ()

A notification callback used by textBufferAddCommitNotify.

You may not modify the TextBuffer from a [callbackgtk.TextBufferCommitNotify] callback and that is enforced by the TextBuffer API.

callbackgtk.TextBufferCommitNotify: may be used to be notified about changes to the underlying buffer right before-or-after the changes are committed to the underlying B-Tree. This is useful if you want to observe changes to the buffer without other signal handlers potentially modifying state on the way to the default signal handler.

When flags is GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT, position is set to the offset in characters from the start of the buffer where the insertion will occur. length is set to the number of characters to be inserted. You may not yet retrieve the text until it has been inserted. You may access the text from GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT using textBufferGetSlice.

When flags is GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT, position is set to offset in characters where the insertion occurred and length is set to the number of characters inserted.

When flags is GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE, position is set to offset in characters where the deletion will occur and length is set to the number of characters that will be removed. You may still retrieve the text from this handler using position and length.

When flags is GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE, length is set to zero to denote that the delete-range has already been committed to the underlying B-Tree. You may no longer retrieve the text that has been deleted from the TextBuffer.

Since: 4.16

drop_closures_TextBufferCommitNotify :: TextBufferCommitNotify -> TextBufferCommitNotify_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextBufferCommitNotify Source #

Arguments

:: (HasCallStack, MonadIO m, IsTextBuffer a)
=> FunPtr C_TextBufferCommitNotify
-> a	`buffer`: the text buffer being notified
-> [TextBufferNotifyFlags]	`flags`: the type of commit notification
-> Word32	`position`: the position of the text operation
-> Word32	`length`: the length of the text operation in characters
-> Ptr ()	`userData`: user data passed to the callback
-> m ()

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

genClosure_TextBufferCommitNotify :: MonadIO m => TextBufferCommitNotify -> m (GClosure C_TextBufferCommitNotify) Source #

Wrap the callback into a GClosure.

mk_TextBufferCommitNotify :: C_TextBufferCommitNotify -> IO (FunPtr C_TextBufferCommitNotify) Source #

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

noTextBufferCommitNotify :: Maybe TextBufferCommitNotify Source #

A convenience synonym for Nothing :: Maybe TextBufferCommitNotify.

noTextBufferCommitNotify_WithClosures :: Maybe TextBufferCommitNotify_WithClosures Source #

A convenience synonym for Nothing :: Maybe TextBufferCommitNotify_WithClosures.

wrap_TextBufferCommitNotify :: Maybe (Ptr (FunPtr C_TextBufferCommitNotify)) -> TextBufferCommitNotify_WithClosures -> C_TextBufferCommitNotify Source #

Wrap a TextBufferCommitNotify into a C_TextBufferCommitNotify.

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.

noTextCharPredicate :: Maybe TextCharPredicate Source #

A convenience synonym for Nothing :: Maybe TextCharPredicate.

noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures Source #

A convenience synonym for Nothing :: Maybe TextCharPredicate_WithClosures.

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

Wrap a TextCharPredicate into 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 `GtkTextTag`
-> IO ()

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

type TextTagTableForeach_WithClosures Source #

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

A simple wrapper that ignores the closure arguments.

dynamic_TextTagTableForeach Source #

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

noTextTagTableForeach :: Maybe TextTagTableForeach Source #

A convenience synonym for Nothing :: Maybe TextTagTableForeach.

noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures Source #

A convenience synonym for Nothing :: Maybe TextTagTableForeach_WithClosures.

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

Wrap a TextTagTableForeach into 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
-> IO Bool	Returns: `G_SOURCE_CONTINUE` if the tick callback should continue to be called, `G_SOURCE_REMOVE` if it 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
-> Ptr ()	`userData`: user data passed to `widgetAddTickCallback`.
-> IO Bool	Returns: `G_SOURCE_CONTINUE` if the tick callback should continue to be called, `G_SOURCE_REMOVE` if it 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
-> Ptr ()	`userData`: user data passed to `widgetAddTickCallback`.
-> m Bool	Returns: `G_SOURCE_CONTINUE` if the tick callback should continue to be called, `G_SOURCE_REMOVE` if it 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.

noTickCallback :: Maybe TickCallback Source #

A convenience synonym for Nothing :: Maybe TickCallback.

noTickCallback_WithClosures :: Maybe TickCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe TickCallback_WithClosures.

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

Wrap a TickCallback into 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 `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 ()

Deprecated: (Since version 4.20)There is no replacement

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.

type TreeCellDataFunc_WithClosures Source #

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.

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

noTreeCellDataFunc :: Maybe TreeCellDataFunc Source #

A convenience synonym for Nothing :: Maybe TreeCellDataFunc.

noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeCellDataFunc_WithClosures.

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

Wrap a TreeCellDataFunc into 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 `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`

Deprecated: (Since version 4.20)There is no replacement

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

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeIterCompareFunc Source #

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

noTreeIterCompareFunc :: Maybe TreeIterCompareFunc Source #

A convenience synonym for Nothing :: Maybe TreeIterCompareFunc.

noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeIterCompareFunc_WithClosures.

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

Wrap a TreeIterCompareFunc into 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.

drop_closures_TreeListModelCreateModelFunc :: TreeListModelCreateModelFunc -> TreeListModelCreateModelFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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.

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

Wrap the callback into a GClosure.

mk_TreeListModelCreateModelFunc :: C_TreeListModelCreateModelFunc -> IO (FunPtr C_TreeListModelCreateModelFunc) Source #

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

noTreeListModelCreateModelFunc :: Maybe TreeListModelCreateModelFunc Source #

A convenience synonym for Nothing :: Maybe TreeListModelCreateModelFunc.

noTreeListModelCreateModelFunc_WithClosures :: Maybe TreeListModelCreateModelFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeListModelCreateModelFunc_WithClosures.

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

Wrap a TreeListModelCreateModelFunc into a C_TreeListModelCreateModelFunc.

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 `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 ()

Deprecated: (Since version 4.20)There is no replacement

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelFilterModifyFunc Source #

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

Wrap the callback into a GClosure.

mk_TreeModelFilterModifyFunc :: C_TreeModelFilterModifyFunc -> IO (FunPtr C_TreeModelFilterModifyFunc) Source #

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

noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc Source #

A convenience synonym for Nothing :: Maybe TreeModelFilterModifyFunc.

noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeModelFilterModifyFunc_WithClosures.

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

Wrap a TreeModelFilterModifyFunc into a C_TreeModelFilterModifyFunc.

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

Deprecated: (Since version 4.20)There is no replacement

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

type TreeModelFilterVisibleFunc_WithClosures Source #

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelFilterVisibleFunc Source #

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

Wrap the callback into a GClosure.

mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc) Source #

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

noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc Source #

A convenience synonym for Nothing :: Maybe TreeModelFilterVisibleFunc.

noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeModelFilterVisibleFunc_WithClosures.

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

Wrap a TreeModelFilterVisibleFunc into a C_TreeModelFilterVisibleFunc.

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 `GtkTreeModel` being iterated
-> TreePath	`path`: the current `GtkTreePath`
-> TreeIter	`iter`: the current `GtkTreeIter`
-> IO Bool	Returns: `True` to stop iterating, `False` to continue

Deprecated: (Since version 4.20)There is no replacement.

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

type TreeModelForeachFunc_WithClosures Source #

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelForeachFunc Source #

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

noTreeModelForeachFunc :: Maybe TreeModelForeachFunc Source #

A convenience synonym for Nothing :: Maybe TreeModelForeachFunc.

noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeModelForeachFunc_WithClosures.

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

Wrap a TreeModelForeachFunc into 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 `GtkTreeModel` being viewed
-> TreePath	`path`: The `GtkTreePath` of a selected row
-> TreeIter	`iter`: A `GtkTreeIter` pointing to a selected row
-> IO ()

Deprecated: (Since version 4.20)There is no replacement

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeSelectionForeachFunc Source #

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

Wrap the callback into a GClosure.

mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc) Source #

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

noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc Source #

A convenience synonym for Nothing :: Maybe TreeSelectionForeachFunc.

noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeSelectionForeachFunc_WithClosures.

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

Wrap a TreeSelectionForeachFunc into a C_TreeSelectionForeachFunc.

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

Deprecated: (Since version 4.20)There is no replacement

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

noTreeSelectionFunc :: Maybe TreeSelectionFunc Source #

A convenience synonym for Nothing :: Maybe TreeSelectionFunc.

noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeSelectionFunc_WithClosures.

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

Wrap a TreeSelectionFunc into 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 `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

Deprecated: (Since version 4.20)There is no replacement.

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewColumnDropFunc Source #

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

Wrap the callback into a GClosure.

mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc) Source #

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

noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc Source #

A convenience synonym for Nothing :: Maybe TreeViewColumnDropFunc.

noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeViewColumnDropFunc_WithClosures.

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

Wrap a TreeViewColumnDropFunc into a C_TreeViewColumnDropFunc.

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 `GtkTreeView`
-> TreePath	`path`: The path that’s expanded
-> IO ()

Deprecated: (Since version 4.20)There is no replacement.

Function used for treeViewMapExpandedRows.

type TreeViewMappingFunc_WithClosures Source #

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewMappingFunc Source #

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

noTreeViewMappingFunc :: Maybe TreeViewMappingFunc Source #

A convenience synonym for Nothing :: Maybe TreeViewMappingFunc.

noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeViewMappingFunc_WithClosures.

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

Wrap a TreeViewMappingFunc into 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 `GtkTreeModel`
-> TreeIter	`iter`: a `GtkTreeIter` pointing at a row in `model`
-> IO Bool	Returns: `True` if the row is a separator

Deprecated: (Since version 4.20)There is no replacement.

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

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewRowSeparatorFunc Source #

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

Wrap the callback into a GClosure.

mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc) Source #

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

noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc Source #

A convenience synonym for Nothing :: Maybe TreeViewRowSeparatorFunc.

noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeViewRowSeparatorFunc_WithClosures.

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

Wrap a TreeViewRowSeparatorFunc into a C_TreeViewRowSeparatorFunc.

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

Deprecated: (Since version 4.20)There is no replacement.

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

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewSearchEqualFunc Source #

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

Wrap the callback into a GClosure.

mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc) Source #

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

noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc Source #

A convenience synonym for Nothing :: Maybe TreeViewSearchEqualFunc.

noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeViewSearchEqualFunc_WithClosures.

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

Wrap a TreeViewSearchEqualFunc into a C_TreeViewSearchEqualFunc.

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

Wrap the callback into a GClosure.

mk_WidgetActionActivateFunc :: C_WidgetActionActivateFunc -> IO (FunPtr C_WidgetActionActivateFunc) Source #

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

noWidgetActionActivateFunc :: Maybe WidgetActionActivateFunc Source #

A convenience synonym for Nothing :: Maybe WidgetActionActivateFunc.

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

Wrap a WidgetActionActivateFunc into a C_WidgetActionActivateFunc.

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.

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

Wrap the callback into a GClosure.

mk_WidgetClassComputeExpandFieldCallback :: C_WidgetClassComputeExpandFieldCallback -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback) Source #

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

noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassComputeExpandFieldCallback.

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

Wrap a WidgetClassComputeExpandFieldCallback into a C_WidgetClassComputeExpandFieldCallback.

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

Wrap the callback into a GClosure.

mk_WidgetClassContainsFieldCallback :: C_WidgetClassContainsFieldCallback -> IO (FunPtr C_WidgetClassContainsFieldCallback) Source #

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

noWidgetClassContainsFieldCallback :: Maybe WidgetClassContainsFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassContainsFieldCallback.

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

Wrap a WidgetClassContainsFieldCallback into a C_WidgetClassContainsFieldCallback.

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.

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

Wrap the callback into a GClosure.

mk_WidgetClassCssChangedFieldCallback :: C_WidgetClassCssChangedFieldCallback -> IO (FunPtr C_WidgetClassCssChangedFieldCallback) Source #

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

noWidgetClassCssChangedFieldCallback :: Maybe WidgetClassCssChangedFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassCssChangedFieldCallback.

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

Wrap a WidgetClassCssChangedFieldCallback into a C_WidgetClassCssChangedFieldCallback.

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.

genClosure_WidgetClassDirectionChangedFieldCallback :: MonadIO m => WidgetClassDirectionChangedFieldCallback -> m (GClosure C_WidgetClassDirectionChangedFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassDirectionChangedFieldCallback :: C_WidgetClassDirectionChangedFieldCallback -> IO (FunPtr C_WidgetClassDirectionChangedFieldCallback) Source #

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

noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassDirectionChangedFieldCallback.

wrap_WidgetClassDirectionChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDirectionChangedFieldCallback)) -> WidgetClassDirectionChangedFieldCallback -> C_WidgetClassDirectionChangedFieldCallback Source #

Wrap a WidgetClassDirectionChangedFieldCallback into a C_WidgetClassDirectionChangedFieldCallback.

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.

genClosure_WidgetClassFocusFieldCallback :: MonadIO m => WidgetClassFocusFieldCallback -> m (GClosure C_WidgetClassFocusFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassFocusFieldCallback :: C_WidgetClassFocusFieldCallback -> IO (FunPtr C_WidgetClassFocusFieldCallback) Source #

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

noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassFocusFieldCallback.

wrap_WidgetClassFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusFieldCallback)) -> WidgetClassFocusFieldCallback -> C_WidgetClassFocusFieldCallback Source #

Wrap a WidgetClassFocusFieldCallback into a C_WidgetClassFocusFieldCallback.

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 `GtkWidget` instance
-> IO SizeRequestMode	Returns: The `GtkSizeRequestMode` 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 `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) Source #

Wrap the callback into a GClosure.

mk_WidgetClassGetRequestModeFieldCallback :: C_WidgetClassGetRequestModeFieldCallback -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback) Source #

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

noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassGetRequestModeFieldCallback.

wrap_WidgetClassGetRequestModeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)) -> WidgetClassGetRequestModeFieldCallback -> C_WidgetClassGetRequestModeFieldCallback Source #

Wrap a WidgetClassGetRequestModeFieldCallback into a C_WidgetClassGetRequestModeFieldCallback.

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.

genClosure_WidgetClassGrabFocusFieldCallback :: MonadIO m => WidgetClassGrabFocusFieldCallback -> m (GClosure C_WidgetClassGrabFocusFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassGrabFocusFieldCallback :: C_WidgetClassGrabFocusFieldCallback -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback) Source #

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

noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassGrabFocusFieldCallback.

wrap_WidgetClassGrabFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)) -> WidgetClassGrabFocusFieldCallback -> C_WidgetClassGrabFocusFieldCallback Source #

Wrap a WidgetClassGrabFocusFieldCallback into a C_WidgetClassGrabFocusFieldCallback.

WidgetClassHideFieldCallback

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

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

type WidgetClassHideFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> IO ()

No description available in the introspection data.

dynamic_WidgetClassHideFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassHideFieldCallback
-> a	`widget`: a widget
-> m ()

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

genClosure_WidgetClassHideFieldCallback :: MonadIO m => WidgetClassHideFieldCallback -> m (GClosure C_WidgetClassHideFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassHideFieldCallback :: C_WidgetClassHideFieldCallback -> IO (FunPtr C_WidgetClassHideFieldCallback) Source #

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

noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassHideFieldCallback.

wrap_WidgetClassHideFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHideFieldCallback)) -> WidgetClassHideFieldCallback -> C_WidgetClassHideFieldCallback Source #

Wrap a WidgetClassHideFieldCallback into a C_WidgetClassHideFieldCallback.

WidgetClassKeynavFailedFieldCallback

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

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

type WidgetClassKeynavFailedFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> DirectionType	`direction`: direction of focus movement
-> IO Bool	Returns: true if stopping keyboard navigation is fine, false if the emitting widget should try to handle the keyboard navigation attempt in its parent widget

No description available in the introspection data.

dynamic_WidgetClassKeynavFailedFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassKeynavFailedFieldCallback
-> a	`widget`: a widget
-> DirectionType	`direction`: direction of focus movement
-> m Bool	Returns: true if stopping keyboard navigation is fine, false if the emitting widget should try to handle the keyboard navigation attempt in its parent widget

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

Wrap the callback into a GClosure.

mk_WidgetClassKeynavFailedFieldCallback :: C_WidgetClassKeynavFailedFieldCallback -> IO (FunPtr C_WidgetClassKeynavFailedFieldCallback) Source #

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

noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassKeynavFailedFieldCallback.

wrap_WidgetClassKeynavFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeynavFailedFieldCallback)) -> WidgetClassKeynavFailedFieldCallback -> C_WidgetClassKeynavFailedFieldCallback Source #

Wrap a WidgetClassKeynavFailedFieldCallback into a C_WidgetClassKeynavFailedFieldCallback.

WidgetClassMapFieldCallback

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

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

type WidgetClassMapFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> IO ()

No description available in the introspection data.

dynamic_WidgetClassMapFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassMapFieldCallback
-> a	`widget`: a widget
-> m ()

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

genClosure_WidgetClassMapFieldCallback :: MonadIO m => WidgetClassMapFieldCallback -> m (GClosure C_WidgetClassMapFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassMapFieldCallback :: C_WidgetClassMapFieldCallback -> IO (FunPtr C_WidgetClassMapFieldCallback) Source #

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

noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassMapFieldCallback.

wrap_WidgetClassMapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapFieldCallback)) -> WidgetClassMapFieldCallback -> C_WidgetClassMapFieldCallback Source #

Wrap a WidgetClassMapFieldCallback into a C_WidgetClassMapFieldCallback.

WidgetClassMeasureFieldCallback

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

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

type WidgetClassMeasureFieldCallback Source #

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

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

Wrap the callback into a GClosure.

mk_WidgetClassMeasureFieldCallback :: C_WidgetClassMeasureFieldCallback -> IO (FunPtr C_WidgetClassMeasureFieldCallback) Source #

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

noWidgetClassMeasureFieldCallback :: Maybe WidgetClassMeasureFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassMeasureFieldCallback.

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

Wrap a WidgetClassMeasureFieldCallback into a C_WidgetClassMeasureFieldCallback.

WidgetClassMnemonicActivateFieldCallback

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

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

type WidgetClassMnemonicActivateFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> Bool	`groupCycling`: true if there are other widgets with the same mnemonic
-> IO Bool	Returns: true if the signal has been handled

No description available in the introspection data.

dynamic_WidgetClassMnemonicActivateFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> a	`widget`: a widget
-> Bool	`groupCycling`: true if there are other widgets with the same mnemonic
-> m Bool	Returns: true if the signal has been handled

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

genClosure_WidgetClassMnemonicActivateFieldCallback :: MonadIO m => WidgetClassMnemonicActivateFieldCallback -> m (GClosure C_WidgetClassMnemonicActivateFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassMnemonicActivateFieldCallback :: C_WidgetClassMnemonicActivateFieldCallback -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback) Source #

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

noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassMnemonicActivateFieldCallback.

wrap_WidgetClassMnemonicActivateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)) -> WidgetClassMnemonicActivateFieldCallback -> C_WidgetClassMnemonicActivateFieldCallback Source #

Wrap a WidgetClassMnemonicActivateFieldCallback into a C_WidgetClassMnemonicActivateFieldCallback.

WidgetClassMoveFocusFieldCallback

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

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

type WidgetClassMoveFocusFieldCallback = Widget -> DirectionType -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassMoveFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMoveFocusFieldCallback -> a -> DirectionType -> m () Source #

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

Wrap the callback into a GClosure.

mk_WidgetClassMoveFocusFieldCallback :: C_WidgetClassMoveFocusFieldCallback -> IO (FunPtr C_WidgetClassMoveFocusFieldCallback) Source #

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

noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassMoveFocusFieldCallback.

wrap_WidgetClassMoveFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMoveFocusFieldCallback)) -> WidgetClassMoveFocusFieldCallback -> C_WidgetClassMoveFocusFieldCallback Source #

Wrap a WidgetClassMoveFocusFieldCallback into a C_WidgetClassMoveFocusFieldCallback.

WidgetClassQueryTooltipFieldCallback

type C_WidgetClassQueryTooltipFieldCallback = Ptr Widget -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> IO CInt Source #

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

type WidgetClassQueryTooltipFieldCallback = Widget -> Int32 -> Int32 -> Bool -> Tooltip -> IO Bool Source #

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

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

Wrap the callback into a GClosure.

mk_WidgetClassQueryTooltipFieldCallback :: C_WidgetClassQueryTooltipFieldCallback -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback) Source #

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

noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassQueryTooltipFieldCallback.

wrap_WidgetClassQueryTooltipFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)) -> WidgetClassQueryTooltipFieldCallback -> C_WidgetClassQueryTooltipFieldCallback Source #

Wrap a WidgetClassQueryTooltipFieldCallback into a C_WidgetClassQueryTooltipFieldCallback.

WidgetClassRealizeFieldCallback

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

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

type WidgetClassRealizeFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> IO ()

No description available in the introspection data.

dynamic_WidgetClassRealizeFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassRealizeFieldCallback
-> a	`widget`: a widget
-> m ()

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

genClosure_WidgetClassRealizeFieldCallback :: MonadIO m => WidgetClassRealizeFieldCallback -> m (GClosure C_WidgetClassRealizeFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassRealizeFieldCallback :: C_WidgetClassRealizeFieldCallback -> IO (FunPtr C_WidgetClassRealizeFieldCallback) Source #

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

noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassRealizeFieldCallback.

wrap_WidgetClassRealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRealizeFieldCallback)) -> WidgetClassRealizeFieldCallback -> C_WidgetClassRealizeFieldCallback Source #

Wrap a WidgetClassRealizeFieldCallback into a C_WidgetClassRealizeFieldCallback.

WidgetClassRootFieldCallback

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

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

type WidgetClassRootFieldCallback = Widget -> IO () Source #

No description available in the introspection data.

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

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

Wrap the callback into a GClosure.

mk_WidgetClassRootFieldCallback :: C_WidgetClassRootFieldCallback -> IO (FunPtr C_WidgetClassRootFieldCallback) Source #

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

noWidgetClassRootFieldCallback :: Maybe WidgetClassRootFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassRootFieldCallback.

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

Wrap a WidgetClassRootFieldCallback into a C_WidgetClassRootFieldCallback.

WidgetClassSetFocusChildFieldCallback

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

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

type WidgetClassSetFocusChildFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> Maybe Widget	`child`: a direct child widget of `widget` or `NULL` to unset the focus child
-> IO ()

No description available in the introspection data.

dynamic_WidgetClassSetFocusChildFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)
=> FunPtr C_WidgetClassSetFocusChildFieldCallback
-> a	`widget`: a widget
-> Maybe b	`child`: a direct child widget of `widget` or `NULL` to unset the focus child
-> 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) Source #

Wrap the callback into a GClosure.

mk_WidgetClassSetFocusChildFieldCallback :: C_WidgetClassSetFocusChildFieldCallback -> IO (FunPtr C_WidgetClassSetFocusChildFieldCallback) Source #

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

noWidgetClassSetFocusChildFieldCallback :: Maybe WidgetClassSetFocusChildFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassSetFocusChildFieldCallback.

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

Wrap a WidgetClassSetFocusChildFieldCallback into a C_WidgetClassSetFocusChildFieldCallback.

WidgetClassShowFieldCallback

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

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

type WidgetClassShowFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> IO ()

No description available in the introspection data.

dynamic_WidgetClassShowFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassShowFieldCallback
-> a	`widget`: a widget
-> m ()

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

genClosure_WidgetClassShowFieldCallback :: MonadIO m => WidgetClassShowFieldCallback -> m (GClosure C_WidgetClassShowFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassShowFieldCallback :: C_WidgetClassShowFieldCallback -> IO (FunPtr C_WidgetClassShowFieldCallback) Source #

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

noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassShowFieldCallback.

wrap_WidgetClassShowFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowFieldCallback)) -> WidgetClassShowFieldCallback -> C_WidgetClassShowFieldCallback Source #

Wrap a WidgetClassShowFieldCallback into a C_WidgetClassShowFieldCallback.

WidgetClassSizeAllocateFieldCallback

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

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

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

No description available in the introspection data.

dynamic_WidgetClassSizeAllocateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSizeAllocateFieldCallback -> a -> Int32 -> Int32 -> Int32 -> m () Source #

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

Wrap the callback into a GClosure.

mk_WidgetClassSizeAllocateFieldCallback :: C_WidgetClassSizeAllocateFieldCallback -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback) Source #

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

noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassSizeAllocateFieldCallback.

wrap_WidgetClassSizeAllocateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)) -> WidgetClassSizeAllocateFieldCallback -> C_WidgetClassSizeAllocateFieldCallback Source #

Wrap a WidgetClassSizeAllocateFieldCallback into a C_WidgetClassSizeAllocateFieldCallback.

WidgetClassSnapshotFieldCallback

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

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

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

No description available in the introspection data.

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

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

Wrap the callback into a GClosure.

mk_WidgetClassSnapshotFieldCallback :: C_WidgetClassSnapshotFieldCallback -> IO (FunPtr C_WidgetClassSnapshotFieldCallback) Source #

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

noWidgetClassSnapshotFieldCallback :: Maybe WidgetClassSnapshotFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassSnapshotFieldCallback.

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

Wrap a WidgetClassSnapshotFieldCallback into a C_WidgetClassSnapshotFieldCallback.

WidgetClassStateFlagsChangedFieldCallback

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

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

type WidgetClassStateFlagsChangedFieldCallback = Widget -> [StateFlags] -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassStateFlagsChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> a -> [StateFlags] -> m () Source #

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

Wrap the callback into a GClosure.

mk_WidgetClassStateFlagsChangedFieldCallback :: C_WidgetClassStateFlagsChangedFieldCallback -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback) Source #

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

noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassStateFlagsChangedFieldCallback.

wrap_WidgetClassStateFlagsChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)) -> WidgetClassStateFlagsChangedFieldCallback -> C_WidgetClassStateFlagsChangedFieldCallback Source #

Wrap a WidgetClassStateFlagsChangedFieldCallback into a C_WidgetClassStateFlagsChangedFieldCallback.

WidgetClassSystemSettingChangedFieldCallback

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

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

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

No description available in the introspection data.

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

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

Wrap the callback into a GClosure.

mk_WidgetClassSystemSettingChangedFieldCallback :: C_WidgetClassSystemSettingChangedFieldCallback -> IO (FunPtr C_WidgetClassSystemSettingChangedFieldCallback) Source #

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

noWidgetClassSystemSettingChangedFieldCallback :: Maybe WidgetClassSystemSettingChangedFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassSystemSettingChangedFieldCallback.

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

Wrap a WidgetClassSystemSettingChangedFieldCallback into a C_WidgetClassSystemSettingChangedFieldCallback.

WidgetClassUnmapFieldCallback

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

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

type WidgetClassUnmapFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> IO ()

No description available in the introspection data.

dynamic_WidgetClassUnmapFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassUnmapFieldCallback
-> a	`widget`: a widget
-> m ()

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

genClosure_WidgetClassUnmapFieldCallback :: MonadIO m => WidgetClassUnmapFieldCallback -> m (GClosure C_WidgetClassUnmapFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassUnmapFieldCallback :: C_WidgetClassUnmapFieldCallback -> IO (FunPtr C_WidgetClassUnmapFieldCallback) Source #

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

noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassUnmapFieldCallback.

wrap_WidgetClassUnmapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapFieldCallback)) -> WidgetClassUnmapFieldCallback -> C_WidgetClassUnmapFieldCallback Source #

Wrap a WidgetClassUnmapFieldCallback into a C_WidgetClassUnmapFieldCallback.

WidgetClassUnrealizeFieldCallback

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

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

type WidgetClassUnrealizeFieldCallback Source #

Arguments

= Widget	`widget`: a widget
-> IO ()

No description available in the introspection data.

dynamic_WidgetClassUnrealizeFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_WidgetClassUnrealizeFieldCallback
-> a	`widget`: a widget
-> m ()

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

genClosure_WidgetClassUnrealizeFieldCallback :: MonadIO m => WidgetClassUnrealizeFieldCallback -> m (GClosure C_WidgetClassUnrealizeFieldCallback) Source #

Wrap the callback into a GClosure.

mk_WidgetClassUnrealizeFieldCallback :: C_WidgetClassUnrealizeFieldCallback -> IO (FunPtr C_WidgetClassUnrealizeFieldCallback) Source #

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

noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassUnrealizeFieldCallback.

wrap_WidgetClassUnrealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrealizeFieldCallback)) -> WidgetClassUnrealizeFieldCallback -> C_WidgetClassUnrealizeFieldCallback Source #

Wrap a WidgetClassUnrealizeFieldCallback into a C_WidgetClassUnrealizeFieldCallback.

WidgetClassUnrootFieldCallback

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

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

type WidgetClassUnrootFieldCallback = Widget -> IO () Source #

No description available in the introspection data.

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

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

Wrap the callback into a GClosure.

mk_WidgetClassUnrootFieldCallback :: C_WidgetClassUnrootFieldCallback -> IO (FunPtr C_WidgetClassUnrootFieldCallback) Source #

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

noWidgetClassUnrootFieldCallback :: Maybe WidgetClassUnrootFieldCallback Source #

A convenience synonym for Nothing :: Maybe WidgetClassUnrootFieldCallback.

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

Wrap a WidgetClassUnrootFieldCallback into a C_WidgetClassUnrootFieldCallback.