Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria (garetxe@gmail.com)
Safe Haskell	None
Language	Haskell2010

GI.Gtk.Callbacks

Contents

Signals

Description

Synopsis

type AccelGroupActivate = AccelGroup -> Object -> Word32 -> [ModifierType] -> IO Bool
type C_AccelGroupActivate = Ptr AccelGroup -> Ptr Object -> Word32 -> CUInt -> IO CInt
dynamic_AccelGroupActivate :: (HasCallStack, MonadIO m, IsAccelGroup a, IsObject b) => FunPtr C_AccelGroupActivate -> a -> b -> Word32 -> [ModifierType] -> m Bool
genClosure_AccelGroupActivate :: AccelGroupActivate -> IO Closure
mk_AccelGroupActivate :: C_AccelGroupActivate -> IO (FunPtr C_AccelGroupActivate)
noAccelGroupActivate :: Maybe AccelGroupActivate
wrap_AccelGroupActivate :: Maybe (Ptr (FunPtr C_AccelGroupActivate)) -> AccelGroupActivate -> C_AccelGroupActivate
type AccelGroupFindFunc = AccelKey -> Closure -> IO Bool
type AccelGroupFindFunc_WithClosures = AccelKey -> Closure -> Ptr () -> IO Bool
type C_AccelGroupFindFunc = Ptr AccelKey -> Ptr Closure -> Ptr () -> IO CInt
drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures
dynamic_AccelGroupFindFunc :: (HasCallStack, MonadIO m) => FunPtr C_AccelGroupFindFunc -> AccelKey -> Closure -> Ptr () -> m Bool
genClosure_AccelGroupFindFunc :: AccelGroupFindFunc -> IO Closure
mk_AccelGroupFindFunc :: C_AccelGroupFindFunc -> IO (FunPtr C_AccelGroupFindFunc)
noAccelGroupFindFunc :: Maybe AccelGroupFindFunc
noAccelGroupFindFunc_WithClosures :: Maybe AccelGroupFindFunc_WithClosures
wrap_AccelGroupFindFunc :: Maybe (Ptr (FunPtr C_AccelGroupFindFunc)) -> AccelGroupFindFunc_WithClosures -> C_AccelGroupFindFunc
type AccelMapForeach = Ptr () -> Text -> Word32 -> [ModifierType] -> Bool -> IO ()
type C_AccelMapForeach = Ptr () -> CString -> Word32 -> CUInt -> CInt -> IO ()
dynamic_AccelMapForeach :: (HasCallStack, MonadIO m) => FunPtr C_AccelMapForeach -> Ptr () -> Text -> Word32 -> [ModifierType] -> Bool -> m ()
genClosure_AccelMapForeach :: AccelMapForeach -> IO Closure
mk_AccelMapForeach :: C_AccelMapForeach -> IO (FunPtr C_AccelMapForeach)
noAccelMapForeach :: Maybe AccelMapForeach
wrap_AccelMapForeach :: Maybe (Ptr (FunPtr C_AccelMapForeach)) -> AccelMapForeach -> C_AccelMapForeach
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 :: AssistantPageFunc -> IO Closure
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 BuilderConnectFunc = Builder -> Object -> Text -> Text -> Maybe Object -> [ConnectFlags] -> IO ()
type BuilderConnectFunc_WithClosures = Builder -> Object -> Text -> Text -> Maybe Object -> [ConnectFlags] -> Ptr () -> IO ()
type C_BuilderConnectFunc = Ptr Builder -> Ptr Object -> CString -> CString -> Ptr Object -> CUInt -> Ptr () -> IO ()
drop_closures_BuilderConnectFunc :: BuilderConnectFunc -> BuilderConnectFunc_WithClosures
dynamic_BuilderConnectFunc :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b, IsObject c) => FunPtr C_BuilderConnectFunc -> a -> b -> Text -> Text -> Maybe c -> [ConnectFlags] -> Ptr () -> m ()
genClosure_BuilderConnectFunc :: BuilderConnectFunc -> IO Closure
mk_BuilderConnectFunc :: C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc)
noBuilderConnectFunc :: Maybe BuilderConnectFunc
noBuilderConnectFunc_WithClosures :: Maybe BuilderConnectFunc_WithClosures
wrap_BuilderConnectFunc :: Maybe (Ptr (FunPtr C_BuilderConnectFunc)) -> BuilderConnectFunc_WithClosures -> C_BuilderConnectFunc
type C_CalendarDetailFunc = Ptr Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO CString
type CalendarDetailFunc = Calendar -> Word32 -> Word32 -> Word32 -> IO (Maybe Text)
type CalendarDetailFunc_WithClosures = Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO (Maybe Text)
drop_closures_CalendarDetailFunc :: CalendarDetailFunc -> CalendarDetailFunc_WithClosures
dynamic_CalendarDetailFunc :: (HasCallStack, MonadIO m, IsCalendar a) => FunPtr C_CalendarDetailFunc -> a -> Word32 -> Word32 -> Word32 -> Ptr () -> m (Maybe Text)
genClosure_CalendarDetailFunc :: CalendarDetailFunc -> IO Closure
mk_CalendarDetailFunc :: C_CalendarDetailFunc -> IO (FunPtr C_CalendarDetailFunc)
noCalendarDetailFunc :: Maybe CalendarDetailFunc
noCalendarDetailFunc_WithClosures :: Maybe CalendarDetailFunc_WithClosures
wrap_CalendarDetailFunc :: Maybe (Ptr (FunPtr C_CalendarDetailFunc)) -> CalendarDetailFunc_WithClosures -> C_CalendarDetailFunc
type C_Callback = Ptr Widget -> Ptr () -> IO ()
type Callback = Widget -> IO ()
type Callback_WithClosures = Widget -> Ptr () -> IO ()
drop_closures_Callback :: Callback -> Callback_WithClosures
dynamic_Callback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_Callback -> a -> Ptr () -> m ()
genClosure_Callback :: Callback -> IO Closure
mk_Callback :: C_Callback -> IO (FunPtr C_Callback)
noCallback :: Maybe Callback
noCallback_WithClosures :: Maybe Callback_WithClosures
wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback_WithClosures -> C_Callback
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 :: CellAllocCallback -> IO Closure
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 :: CellCallback -> IO Closure
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 :: CellLayoutDataFunc -> IO Closure
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_ClipboardClearFunc = Ptr Clipboard -> Ptr () -> IO ()
type ClipboardClearFunc = Clipboard -> Ptr () -> IO ()
dynamic_ClipboardClearFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardClearFunc -> a -> Ptr () -> m ()
genClosure_ClipboardClearFunc :: ClipboardClearFunc -> IO Closure
mk_ClipboardClearFunc :: C_ClipboardClearFunc -> IO (FunPtr C_ClipboardClearFunc)
noClipboardClearFunc :: Maybe ClipboardClearFunc
wrap_ClipboardClearFunc :: Maybe (Ptr (FunPtr C_ClipboardClearFunc)) -> ClipboardClearFunc -> C_ClipboardClearFunc
type C_ClipboardGetFunc = Ptr Clipboard -> Ptr SelectionData -> Word32 -> Ptr () -> IO ()
type ClipboardGetFunc = Clipboard -> SelectionData -> Word32 -> Ptr () -> IO ()
dynamic_ClipboardGetFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardGetFunc -> a -> SelectionData -> Word32 -> Ptr () -> m ()
genClosure_ClipboardGetFunc :: ClipboardGetFunc -> IO Closure
mk_ClipboardGetFunc :: C_ClipboardGetFunc -> IO (FunPtr C_ClipboardGetFunc)
noClipboardGetFunc :: Maybe ClipboardGetFunc
wrap_ClipboardGetFunc :: Maybe (Ptr (FunPtr C_ClipboardGetFunc)) -> ClipboardGetFunc -> C_ClipboardGetFunc
type C_ClipboardImageReceivedFunc = Ptr Clipboard -> Ptr Pixbuf -> Ptr () -> IO ()
type ClipboardImageReceivedFunc = Clipboard -> Pixbuf -> IO ()
type ClipboardImageReceivedFunc_WithClosures = Clipboard -> Pixbuf -> Ptr () -> IO ()
drop_closures_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> ClipboardImageReceivedFunc_WithClosures
dynamic_ClipboardImageReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b) => FunPtr C_ClipboardImageReceivedFunc -> a -> b -> Ptr () -> m ()
genClosure_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> IO Closure
mk_ClipboardImageReceivedFunc :: C_ClipboardImageReceivedFunc -> IO (FunPtr C_ClipboardImageReceivedFunc)
noClipboardImageReceivedFunc :: Maybe ClipboardImageReceivedFunc
noClipboardImageReceivedFunc_WithClosures :: Maybe ClipboardImageReceivedFunc_WithClosures
wrap_ClipboardImageReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardImageReceivedFunc)) -> ClipboardImageReceivedFunc_WithClosures -> C_ClipboardImageReceivedFunc
type C_ClipboardReceivedFunc = Ptr Clipboard -> Ptr SelectionData -> Ptr () -> IO ()
type ClipboardReceivedFunc = Clipboard -> SelectionData -> IO ()
type ClipboardReceivedFunc_WithClosures = Clipboard -> SelectionData -> Ptr () -> IO ()
drop_closures_ClipboardReceivedFunc :: ClipboardReceivedFunc -> ClipboardReceivedFunc_WithClosures
dynamic_ClipboardReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardReceivedFunc -> a -> SelectionData -> Ptr () -> m ()
genClosure_ClipboardReceivedFunc :: ClipboardReceivedFunc -> IO Closure
mk_ClipboardReceivedFunc :: C_ClipboardReceivedFunc -> IO (FunPtr C_ClipboardReceivedFunc)
noClipboardReceivedFunc :: Maybe ClipboardReceivedFunc
noClipboardReceivedFunc_WithClosures :: Maybe ClipboardReceivedFunc_WithClosures
wrap_ClipboardReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardReceivedFunc)) -> ClipboardReceivedFunc_WithClosures -> C_ClipboardReceivedFunc
type C_ClipboardRichTextReceivedFunc = Ptr Clipboard -> Ptr Atom -> CString -> Word64 -> Ptr () -> IO ()
type ClipboardRichTextReceivedFunc = Clipboard -> Atom -> Maybe Text -> Word64 -> IO ()
type ClipboardRichTextReceivedFunc_WithClosures = Clipboard -> Atom -> Maybe Text -> Word64 -> Ptr () -> IO ()
drop_closures_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> ClipboardRichTextReceivedFunc_WithClosures
dynamic_ClipboardRichTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardRichTextReceivedFunc -> a -> Atom -> Maybe Text -> Word64 -> Ptr () -> m ()
genClosure_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> IO Closure
mk_ClipboardRichTextReceivedFunc :: C_ClipboardRichTextReceivedFunc -> IO (FunPtr C_ClipboardRichTextReceivedFunc)
noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc
noClipboardRichTextReceivedFunc_WithClosures :: Maybe ClipboardRichTextReceivedFunc_WithClosures
wrap_ClipboardRichTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardRichTextReceivedFunc)) -> ClipboardRichTextReceivedFunc_WithClosures -> C_ClipboardRichTextReceivedFunc
type C_ClipboardTargetsReceivedFunc = Ptr Clipboard -> Ptr (Ptr Atom) -> Int32 -> Ptr () -> IO ()
type ClipboardTargetsReceivedFunc = Clipboard -> Maybe [Atom] -> IO ()
type ClipboardTargetsReceivedFunc_WithClosures = Clipboard -> Maybe [Atom] -> Ptr () -> IO ()
drop_closures_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> ClipboardTargetsReceivedFunc_WithClosures
dynamic_ClipboardTargetsReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTargetsReceivedFunc -> a -> Maybe [Atom] -> Ptr () -> m ()
genClosure_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> IO Closure
mk_ClipboardTargetsReceivedFunc :: C_ClipboardTargetsReceivedFunc -> IO (FunPtr C_ClipboardTargetsReceivedFunc)
noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc
noClipboardTargetsReceivedFunc_WithClosures :: Maybe ClipboardTargetsReceivedFunc_WithClosures
wrap_ClipboardTargetsReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTargetsReceivedFunc)) -> ClipboardTargetsReceivedFunc_WithClosures -> C_ClipboardTargetsReceivedFunc
type C_ClipboardTextReceivedFunc = Ptr Clipboard -> CString -> Ptr () -> IO ()
type ClipboardTextReceivedFunc = Clipboard -> Maybe Text -> IO ()
type ClipboardTextReceivedFunc_WithClosures = Clipboard -> Maybe Text -> Ptr () -> IO ()
drop_closures_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> ClipboardTextReceivedFunc_WithClosures
dynamic_ClipboardTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTextReceivedFunc -> a -> Maybe Text -> Ptr () -> m ()
genClosure_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> IO Closure
mk_ClipboardTextReceivedFunc :: C_ClipboardTextReceivedFunc -> IO (FunPtr C_ClipboardTextReceivedFunc)
noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc
noClipboardTextReceivedFunc_WithClosures :: Maybe ClipboardTextReceivedFunc_WithClosures
wrap_ClipboardTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTextReceivedFunc)) -> ClipboardTextReceivedFunc_WithClosures -> C_ClipboardTextReceivedFunc
type C_ClipboardURIReceivedFunc = Ptr Clipboard -> Ptr CString -> Ptr () -> IO ()
type ClipboardURIReceivedFunc = Clipboard -> [Text] -> IO ()
type ClipboardURIReceivedFunc_WithClosures = Clipboard -> [Text] -> Ptr () -> IO ()
drop_closures_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> ClipboardURIReceivedFunc_WithClosures
dynamic_ClipboardURIReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardURIReceivedFunc -> a -> [Text] -> Ptr () -> m ()
genClosure_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> IO Closure
mk_ClipboardURIReceivedFunc :: C_ClipboardURIReceivedFunc -> IO (FunPtr C_ClipboardURIReceivedFunc)
noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc
noClipboardURIReceivedFunc_WithClosures :: Maybe ClipboardURIReceivedFunc_WithClosures
wrap_ClipboardURIReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardURIReceivedFunc)) -> ClipboardURIReceivedFunc_WithClosures -> C_ClipboardURIReceivedFunc
type C_ColorSelectionChangePaletteFunc = Ptr Color -> Int32 -> IO ()
type ColorSelectionChangePaletteFunc = [Color] -> IO ()
dynamic_ColorSelectionChangePaletteFunc :: (HasCallStack, MonadIO m) => FunPtr C_ColorSelectionChangePaletteFunc -> [Color] -> m ()
genClosure_ColorSelectionChangePaletteFunc :: ColorSelectionChangePaletteFunc -> IO Closure
mk_ColorSelectionChangePaletteFunc :: C_ColorSelectionChangePaletteFunc -> IO (FunPtr C_ColorSelectionChangePaletteFunc)
noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc
wrap_ColorSelectionChangePaletteFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteFunc)) -> ColorSelectionChangePaletteFunc -> C_ColorSelectionChangePaletteFunc
type C_ColorSelectionChangePaletteWithScreenFunc = Ptr Screen -> Ptr Color -> Int32 -> IO ()
type ColorSelectionChangePaletteWithScreenFunc = Screen -> [Color] -> IO ()
dynamic_ColorSelectionChangePaletteWithScreenFunc :: (HasCallStack, MonadIO m, IsScreen a) => FunPtr C_ColorSelectionChangePaletteWithScreenFunc -> a -> [Color] -> m ()
genClosure_ColorSelectionChangePaletteWithScreenFunc :: ColorSelectionChangePaletteWithScreenFunc -> IO Closure
mk_ColorSelectionChangePaletteWithScreenFunc :: C_ColorSelectionChangePaletteWithScreenFunc -> IO (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)
noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc
wrap_ColorSelectionChangePaletteWithScreenFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)) -> ColorSelectionChangePaletteWithScreenFunc -> C_ColorSelectionChangePaletteWithScreenFunc
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 :: EntryCompletionMatchFunc -> IO Closure
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_FileFilterFunc = Ptr FileFilterInfo -> Ptr () -> IO CInt
type FileFilterFunc = FileFilterInfo -> IO Bool
type FileFilterFunc_WithClosures = FileFilterInfo -> Ptr () -> IO Bool
drop_closures_FileFilterFunc :: FileFilterFunc -> FileFilterFunc_WithClosures
dynamic_FileFilterFunc :: (HasCallStack, MonadIO m) => FunPtr C_FileFilterFunc -> FileFilterInfo -> Ptr () -> m Bool
genClosure_FileFilterFunc :: FileFilterFunc -> IO Closure
mk_FileFilterFunc :: C_FileFilterFunc -> IO (FunPtr C_FileFilterFunc)
noFileFilterFunc :: Maybe FileFilterFunc
noFileFilterFunc_WithClosures :: Maybe FileFilterFunc_WithClosures
wrap_FileFilterFunc :: Maybe (Ptr (FunPtr C_FileFilterFunc)) -> FileFilterFunc_WithClosures -> C_FileFilterFunc
type C_FlowBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO (Ptr Widget)
type FlowBoxCreateWidgetFunc = Maybe Object -> IO Widget
type FlowBoxCreateWidgetFunc_WithClosures = Maybe Object -> Ptr () -> IO Widget
drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures
dynamic_FlowBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_FlowBoxCreateWidgetFunc -> Maybe a -> Ptr () -> m Widget
genClosure_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> IO Closure
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 :: FlowBoxFilterFunc -> IO Closure
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 :: FlowBoxForeachFunc -> IO Closure
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 :: FlowBoxSortFunc -> IO Closure
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 :: FontFilterFunc -> IO Closure
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 :: IconViewForeachFunc -> IO Closure
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_KeySnoopFunc = Ptr Widget -> Ptr EventKey -> Ptr () -> IO Int32
type KeySnoopFunc = Widget -> EventKey -> IO Int32
type KeySnoopFunc_WithClosures = Widget -> EventKey -> Ptr () -> IO Int32
drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures
dynamic_KeySnoopFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_KeySnoopFunc -> a -> EventKey -> Ptr () -> m Int32
genClosure_KeySnoopFunc :: KeySnoopFunc -> IO Closure
mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc)
noKeySnoopFunc :: Maybe KeySnoopFunc
noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures
wrap_KeySnoopFunc :: Maybe (Ptr (FunPtr C_KeySnoopFunc)) -> KeySnoopFunc_WithClosures -> C_KeySnoopFunc
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 :: ListBoxCreateWidgetFunc -> IO Closure
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 :: ListBoxFilterFunc -> IO Closure
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 :: ListBoxForeachFunc -> IO Closure
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 :: ListBoxSortFunc -> IO Closure
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 :: ListBoxUpdateHeaderFunc -> IO Closure
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_MenuDetachFunc = Ptr Widget -> Ptr Menu -> IO ()
type MenuDetachFunc = Widget -> Menu -> IO ()
dynamic_MenuDetachFunc :: (HasCallStack, MonadIO m, IsWidget a, IsMenu b) => FunPtr C_MenuDetachFunc -> a -> b -> m ()
genClosure_MenuDetachFunc :: MenuDetachFunc -> IO Closure
mk_MenuDetachFunc :: C_MenuDetachFunc -> IO (FunPtr C_MenuDetachFunc)
noMenuDetachFunc :: Maybe MenuDetachFunc
wrap_MenuDetachFunc :: Maybe (Ptr (FunPtr C_MenuDetachFunc)) -> MenuDetachFunc -> C_MenuDetachFunc
type C_MenuPositionFunc = Ptr Menu -> Ptr Int32 -> Ptr Int32 -> Ptr CInt -> Ptr () -> IO ()
type MenuPositionFunc = Menu -> Int32 -> Int32 -> IO (Int32, Int32, Bool)
type MenuPositionFunc_WithClosures = Menu -> Int32 -> Int32 -> Ptr () -> IO (Int32, Int32, Bool)
drop_closures_MenuPositionFunc :: MenuPositionFunc -> MenuPositionFunc_WithClosures
dynamic_MenuPositionFunc :: (HasCallStack, MonadIO m, IsMenu a) => FunPtr C_MenuPositionFunc -> a -> Int32 -> Int32 -> Ptr () -> m (Int32, Int32, Bool)
genClosure_MenuPositionFunc :: MenuPositionFunc -> IO Closure
mk_MenuPositionFunc :: C_MenuPositionFunc -> IO (FunPtr C_MenuPositionFunc)
noMenuPositionFunc :: Maybe MenuPositionFunc
noMenuPositionFunc_WithClosures :: Maybe MenuPositionFunc_WithClosures
wrap_MenuPositionFunc :: Maybe (Ptr (FunPtr C_MenuPositionFunc)) -> MenuPositionFunc_WithClosures -> C_MenuPositionFunc
type C_ModuleDisplayInitFunc = Ptr Display -> IO ()
type ModuleDisplayInitFunc = Display -> IO ()
dynamic_ModuleDisplayInitFunc :: (HasCallStack, MonadIO m, IsDisplay a) => FunPtr C_ModuleDisplayInitFunc -> a -> m ()
genClosure_ModuleDisplayInitFunc :: ModuleDisplayInitFunc -> IO Closure
mk_ModuleDisplayInitFunc :: C_ModuleDisplayInitFunc -> IO (FunPtr C_ModuleDisplayInitFunc)
noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc
wrap_ModuleDisplayInitFunc :: Maybe (Ptr (FunPtr C_ModuleDisplayInitFunc)) -> ModuleDisplayInitFunc -> C_ModuleDisplayInitFunc
type C_ModuleInitFunc = Int32 -> Ptr CString -> IO ()
type ModuleInitFunc = Maybe [Text] -> IO ()
dynamic_ModuleInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ModuleInitFunc -> Maybe [Text] -> m ()
genClosure_ModuleInitFunc :: ModuleInitFunc -> IO Closure
mk_ModuleInitFunc :: C_ModuleInitFunc -> IO (FunPtr C_ModuleInitFunc)
noModuleInitFunc :: Maybe ModuleInitFunc
wrap_ModuleInitFunc :: Maybe (Ptr (FunPtr C_ModuleInitFunc)) -> ModuleInitFunc -> C_ModuleInitFunc
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 :: PageSetupDoneFunc -> IO Closure
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_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 :: PrintSettingsFunc -> IO Closure
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_RcPropertyParser = Ptr GParamSpec -> Ptr String -> Ptr GValue -> IO CInt
type RcPropertyParser = GParamSpec -> String -> GValue -> IO Bool
dynamic_RcPropertyParser :: (HasCallStack, MonadIO m) => FunPtr C_RcPropertyParser -> GParamSpec -> String -> GValue -> m Bool
genClosure_RcPropertyParser :: RcPropertyParser -> IO Closure
mk_RcPropertyParser :: C_RcPropertyParser -> IO (FunPtr C_RcPropertyParser)
noRcPropertyParser :: Maybe RcPropertyParser
wrap_RcPropertyParser :: Maybe (Ptr (FunPtr C_RcPropertyParser)) -> RcPropertyParser -> C_RcPropertyParser
type C_RecentFilterFunc = Ptr RecentFilterInfo -> Ptr () -> IO CInt
type RecentFilterFunc = RecentFilterInfo -> IO Bool
type RecentFilterFunc_WithClosures = RecentFilterInfo -> Ptr () -> IO Bool
drop_closures_RecentFilterFunc :: RecentFilterFunc -> RecentFilterFunc_WithClosures
dynamic_RecentFilterFunc :: (HasCallStack, MonadIO m) => FunPtr C_RecentFilterFunc -> RecentFilterInfo -> Ptr () -> m Bool
genClosure_RecentFilterFunc :: RecentFilterFunc -> IO Closure
mk_RecentFilterFunc :: C_RecentFilterFunc -> IO (FunPtr C_RecentFilterFunc)
noRecentFilterFunc :: Maybe RecentFilterFunc
noRecentFilterFunc_WithClosures :: Maybe RecentFilterFunc_WithClosures
wrap_RecentFilterFunc :: Maybe (Ptr (FunPtr C_RecentFilterFunc)) -> RecentFilterFunc_WithClosures -> C_RecentFilterFunc
type C_RecentSortFunc = Ptr RecentInfo -> Ptr RecentInfo -> Ptr () -> IO Int32
type RecentSortFunc = RecentInfo -> RecentInfo -> IO Int32
type RecentSortFunc_WithClosures = RecentInfo -> RecentInfo -> Ptr () -> IO Int32
drop_closures_RecentSortFunc :: RecentSortFunc -> RecentSortFunc_WithClosures
dynamic_RecentSortFunc :: (HasCallStack, MonadIO m) => FunPtr C_RecentSortFunc -> RecentInfo -> RecentInfo -> Ptr () -> m Int32
genClosure_RecentSortFunc :: RecentSortFunc -> IO Closure
mk_RecentSortFunc :: C_RecentSortFunc -> IO (FunPtr C_RecentSortFunc)
noRecentSortFunc :: Maybe RecentSortFunc
noRecentSortFunc_WithClosures :: Maybe RecentSortFunc_WithClosures
wrap_RecentSortFunc :: Maybe (Ptr (FunPtr C_RecentSortFunc)) -> RecentSortFunc_WithClosures -> C_RecentSortFunc
type C_StylePropertyParser = CString -> Ptr GValue -> Ptr (Ptr GError) -> IO CInt
type StylePropertyParser = Text -> GValue -> IO ()
dynamic_StylePropertyParser :: (HasCallStack, MonadIO m) => FunPtr C_StylePropertyParser -> Text -> GValue -> m ()
mk_StylePropertyParser :: C_StylePropertyParser -> IO (FunPtr C_StylePropertyParser)
noStylePropertyParser :: Maybe StylePropertyParser
type C_TextBufferDeserializeFunc = Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr Word8 -> Word64 -> CInt -> Ptr () -> Ptr (Ptr GError) -> IO CInt
type TextBufferDeserializeFunc = TextBuffer -> TextBuffer -> TextIter -> ByteString -> Bool -> IO ()
type TextBufferDeserializeFunc_WithClosures = TextBuffer -> TextBuffer -> TextIter -> ByteString -> Bool -> Ptr () -> IO ()
drop_closures_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> TextBufferDeserializeFunc_WithClosures
dynamic_TextBufferDeserializeFunc :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => FunPtr C_TextBufferDeserializeFunc -> a -> b -> TextIter -> ByteString -> Bool -> Ptr () -> m ()
mk_TextBufferDeserializeFunc :: C_TextBufferDeserializeFunc -> IO (FunPtr C_TextBufferDeserializeFunc)
noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc
noTextBufferDeserializeFunc_WithClosures :: Maybe TextBufferDeserializeFunc_WithClosures
type C_TextBufferSerializeFunc = Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr TextIter -> Word64 -> Ptr () -> IO Word8
type TextBufferSerializeFunc = TextBuffer -> TextBuffer -> TextIter -> TextIter -> Word64 -> IO Word8
type TextBufferSerializeFunc_WithClosures = TextBuffer -> TextBuffer -> TextIter -> TextIter -> Word64 -> Ptr () -> IO Word8
drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures
dynamic_TextBufferSerializeFunc :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => FunPtr C_TextBufferSerializeFunc -> a -> b -> TextIter -> TextIter -> Word64 -> Ptr () -> m Word8
genClosure_TextBufferSerializeFunc :: TextBufferSerializeFunc -> IO Closure
mk_TextBufferSerializeFunc :: C_TextBufferSerializeFunc -> IO (FunPtr C_TextBufferSerializeFunc)
noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc
noTextBufferSerializeFunc_WithClosures :: Maybe TextBufferSerializeFunc_WithClosures
wrap_TextBufferSerializeFunc :: Maybe (Ptr (FunPtr C_TextBufferSerializeFunc)) -> TextBufferSerializeFunc_WithClosures -> C_TextBufferSerializeFunc
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 :: TextCharPredicate -> IO Closure
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 :: TextTagTableForeach -> IO Closure
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 :: TickCallback -> IO Closure
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_TranslateFunc = CString -> Ptr () -> IO CString
type TranslateFunc = Text -> IO Text
type TranslateFunc_WithClosures = Text -> Ptr () -> IO Text
drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures
dynamic_TranslateFunc :: (HasCallStack, MonadIO m) => FunPtr C_TranslateFunc -> Text -> Ptr () -> m Text
genClosure_TranslateFunc :: TranslateFunc -> IO Closure
mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc)
noTranslateFunc :: Maybe TranslateFunc
noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures
wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc_WithClosures -> C_TranslateFunc
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 :: TreeCellDataFunc -> IO Closure
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_TreeDestroyCountFunc = Ptr TreeView -> Ptr TreePath -> Int32 -> Ptr () -> IO ()
type TreeDestroyCountFunc = TreeView -> TreePath -> Int32 -> IO ()
type TreeDestroyCountFunc_WithClosures = TreeView -> TreePath -> Int32 -> Ptr () -> IO ()
drop_closures_TreeDestroyCountFunc :: TreeDestroyCountFunc -> TreeDestroyCountFunc_WithClosures
dynamic_TreeDestroyCountFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeDestroyCountFunc -> a -> TreePath -> Int32 -> Ptr () -> m ()
genClosure_TreeDestroyCountFunc :: TreeDestroyCountFunc -> IO Closure
mk_TreeDestroyCountFunc :: C_TreeDestroyCountFunc -> IO (FunPtr C_TreeDestroyCountFunc)
noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc
noTreeDestroyCountFunc_WithClosures :: Maybe TreeDestroyCountFunc_WithClosures
wrap_TreeDestroyCountFunc :: Maybe (Ptr (FunPtr C_TreeDestroyCountFunc)) -> TreeDestroyCountFunc_WithClosures -> C_TreeDestroyCountFunc
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 :: TreeIterCompareFunc -> IO Closure
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_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 :: TreeModelFilterVisibleFunc -> IO Closure
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 :: TreeModelForeachFunc -> IO Closure
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 :: TreeSelectionForeachFunc -> IO Closure
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 :: TreeSelectionFunc -> IO Closure
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 :: TreeViewColumnDropFunc -> IO Closure
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 :: TreeViewMappingFunc -> IO Closure
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 :: TreeViewRowSeparatorFunc -> IO Closure
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 :: TreeViewSearchEqualFunc -> IO Closure
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_TreeViewSearchPositionFunc = Ptr TreeView -> Ptr Widget -> Ptr () -> IO ()
type TreeViewSearchPositionFunc = TreeView -> Widget -> IO ()
type TreeViewSearchPositionFunc_WithClosures = TreeView -> Widget -> Ptr () -> IO ()
drop_closures_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> TreeViewSearchPositionFunc_WithClosures
dynamic_TreeViewSearchPositionFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsWidget b) => FunPtr C_TreeViewSearchPositionFunc -> a -> b -> Ptr () -> m ()
genClosure_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> IO Closure
mk_TreeViewSearchPositionFunc :: C_TreeViewSearchPositionFunc -> IO (FunPtr C_TreeViewSearchPositionFunc)
noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc
noTreeViewSearchPositionFunc_WithClosures :: Maybe TreeViewSearchPositionFunc_WithClosures
wrap_TreeViewSearchPositionFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchPositionFunc)) -> TreeViewSearchPositionFunc_WithClosures -> C_TreeViewSearchPositionFunc

Signals

AccelGroupActivate

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

No description available in the introspection data.

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

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

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

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

genClosure_AccelGroupActivate :: AccelGroupActivate -> IO Closure Source #

Wrap the callback into a Closure.

mk_AccelGroupActivate :: C_AccelGroupActivate -> IO (FunPtr C_AccelGroupActivate) Source #

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

noAccelGroupActivate :: Maybe AccelGroupActivate Source #

A convenience synonym for Nothing :: Maybe AccelGroupActivate.

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

Wrap a AccelGroupActivate into a C_AccelGroupActivate.

AccelGroupFindFunc

type AccelGroupFindFunc = AccelKey -> Closure -> IO Bool Source #

No description available in the introspection data.

Since: 2.2

type AccelGroupFindFunc_WithClosures = AccelKey -> Closure -> Ptr () -> IO Bool Source #

No description available in the introspection data.

Since: 2.2

type C_AccelGroupFindFunc = Ptr AccelKey -> Ptr Closure -> Ptr () -> IO CInt Source #

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

drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_AccelGroupFindFunc :: (HasCallStack, MonadIO m) => FunPtr C_AccelGroupFindFunc -> AccelKey -> Closure -> Ptr () -> m Bool Source #

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

genClosure_AccelGroupFindFunc :: AccelGroupFindFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_AccelGroupFindFunc :: C_AccelGroupFindFunc -> IO (FunPtr C_AccelGroupFindFunc) Source #

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

noAccelGroupFindFunc :: Maybe AccelGroupFindFunc Source #

A convenience synonym for Nothing :: Maybe AccelGroupFindFunc.

noAccelGroupFindFunc_WithClosures :: Maybe AccelGroupFindFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe AccelGroupFindFunc_WithClosures.

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

Wrap a AccelGroupFindFunc into a C_AccelGroupFindFunc.

AccelMapForeach

type AccelMapForeach Source #

Arguments

= Ptr ()	`data`: User data passed to `accelMapForeach` or `accelMapForeachUnfiltered`
-> Text	`accelPath`: Accel path of the current accelerator
-> Word32	`accelKey`: Key of the current accelerator
-> [ModifierType]	`accelMods`: Modifiers of the current accelerator
-> Bool	`changed`: Changed flag of the accelerator (if `True`, accelerator has changed during runtime and would need to be saved during an accelerator dump)
-> IO ()

No description available in the introspection data.

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

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

dynamic_AccelMapForeach Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_AccelMapForeach
-> Ptr ()	`data`: User data passed to `accelMapForeach` or `accelMapForeachUnfiltered`
-> Text	`accelPath`: Accel path of the current accelerator
-> Word32	`accelKey`: Key of the current accelerator
-> [ModifierType]	`accelMods`: Modifiers of the current accelerator
-> Bool	`changed`: Changed flag of the accelerator (if `True`, accelerator has changed during runtime and would need to be saved during an accelerator dump)
-> m ()

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

genClosure_AccelMapForeach :: AccelMapForeach -> IO Closure Source #

Wrap the callback into a Closure.

mk_AccelMapForeach :: C_AccelMapForeach -> IO (FunPtr C_AccelMapForeach) Source #

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

noAccelMapForeach :: Maybe AccelMapForeach Source #

A convenience synonym for Nothing :: Maybe AccelMapForeach.

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

Wrap a AccelMapForeach into a C_AccelMapForeach.

AssistantPageFunc

type AssistantPageFunc Source #

Arguments

= Int32	`currentPage`: The page number used to calculate the next page.
-> IO Int32	Returns: The next page number.

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

type AssistantPageFunc_WithClosures Source #

Arguments

= Int32	`currentPage`: The page number used to calculate the next page.
-> Ptr ()	`data`: user data.
-> IO Int32	Returns: The next page number.

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

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

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

drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_AssistantPageFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_AssistantPageFunc
-> Int32	`currentPage`: The page number used to calculate the next page.
-> Ptr ()	`data`: user data.
-> m Int32	Returns: The next page number.

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

genClosure_AssistantPageFunc :: AssistantPageFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

BuilderConnectFunc

type BuilderConnectFunc Source #

Arguments

= Builder	`builder`: a `Builder`
-> Object	`object`: object to connect a signal to
-> Text	`signalName`: name of the signal
-> Text	`handlerName`: name of the handler
-> Maybe Object	`connectObject`: a `Object`, if non-`Nothing`, use `g_signal_connect_object()`
-> [ConnectFlags]	`flags`: `ConnectFlags` to use
-> IO ()

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

Since: 2.12

type BuilderConnectFunc_WithClosures Source #

Arguments

= Builder	`builder`: a `Builder`
-> Object	`object`: object to connect a signal to
-> Text	`signalName`: name of the signal
-> Text	`handlerName`: name of the handler
-> Maybe Object	`connectObject`: a `Object`, if non-`Nothing`, use `g_signal_connect_object()`
-> [ConnectFlags]	`flags`: `ConnectFlags` to use
-> Ptr ()	`userData`: user data
-> IO ()

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

Since: 2.12

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

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

drop_closures_BuilderConnectFunc :: BuilderConnectFunc -> BuilderConnectFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BuilderConnectFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsBuilder a, IsObject b, IsObject c)
=> FunPtr C_BuilderConnectFunc
-> a	`builder`: a `Builder`
-> b	`object`: object to connect a signal to
-> Text	`signalName`: name of the signal
-> Text	`handlerName`: name of the handler
-> Maybe c	`connectObject`: a `Object`, if non-`Nothing`, use `g_signal_connect_object()`
-> [ConnectFlags]	`flags`: `ConnectFlags` to use
-> Ptr ()	`userData`: user data
-> m ()

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

genClosure_BuilderConnectFunc :: BuilderConnectFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_BuilderConnectFunc :: C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc) Source #

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

noBuilderConnectFunc :: Maybe BuilderConnectFunc Source #

A convenience synonym for Nothing :: Maybe BuilderConnectFunc.

noBuilderConnectFunc_WithClosures :: Maybe BuilderConnectFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe BuilderConnectFunc_WithClosures.

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

Wrap a BuilderConnectFunc into a C_BuilderConnectFunc.

CalendarDetailFunc

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

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

type CalendarDetailFunc Source #

Arguments

= Calendar	`calendar`: a `Calendar`.
-> Word32	`year`: the year for which details are needed.
-> Word32	`month`: the month for which details are needed.
-> Word32	`day`: the day of `month` for which details are needed.
-> IO (Maybe Text)	Returns: Newly allocated string with Pango markup with details for the specified day or `Nothing`.

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

Since: 2.14

type CalendarDetailFunc_WithClosures Source #

Arguments

= Calendar	`calendar`: a `Calendar`.
-> Word32	`year`: the year for which details are needed.
-> Word32	`month`: the month for which details are needed.
-> Word32	`day`: the day of `month` for which details are needed.
-> Ptr ()	`userData`: the data passed with `calendarSetDetailFunc`.
-> IO (Maybe Text)	Returns: Newly allocated string with Pango markup with details for the specified day or `Nothing`.

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

Since: 2.14

drop_closures_CalendarDetailFunc :: CalendarDetailFunc -> CalendarDetailFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CalendarDetailFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsCalendar a)
=> FunPtr C_CalendarDetailFunc
-> a	`calendar`: a `Calendar`.
-> Word32	`year`: the year for which details are needed.
-> Word32	`month`: the month for which details are needed.
-> Word32	`day`: the day of `month` for which details are needed.
-> Ptr ()	`userData`: the data passed with `calendarSetDetailFunc`.
-> m (Maybe Text)	Returns: Newly allocated string with Pango markup with details for the specified day or `Nothing`.

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

genClosure_CalendarDetailFunc :: CalendarDetailFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_CalendarDetailFunc :: C_CalendarDetailFunc -> IO (FunPtr C_CalendarDetailFunc) Source #

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

noCalendarDetailFunc :: Maybe CalendarDetailFunc Source #

A convenience synonym for Nothing :: Maybe CalendarDetailFunc.

noCalendarDetailFunc_WithClosures :: Maybe CalendarDetailFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe CalendarDetailFunc_WithClosures.

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

Wrap a CalendarDetailFunc into a C_CalendarDetailFunc.

Callback

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

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

type Callback Source #

Arguments

= Widget	`widget`: the widget to operate on
-> IO ()

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

type Callback_WithClosures Source #

Arguments

= Widget	`widget`: the widget to operate on
-> Ptr ()	`data`: user-supplied data
-> IO ()

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

drop_closures_Callback :: Callback -> Callback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_Callback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_Callback
-> a	`widget`: the widget to operate on
-> Ptr ()	`data`: user-supplied data
-> m ()

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

genClosure_Callback :: Callback -> IO Closure Source #

Wrap the callback into a Closure.

mk_Callback :: C_Callback -> IO (FunPtr C_Callback) Source #

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

noCallback :: Maybe Callback Source #

A convenience synonym for Nothing :: Maybe Callback.

noCallback_WithClosures :: Maybe Callback_WithClosures Source #

A convenience synonym for Nothing :: Maybe Callback_WithClosures.

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

Wrap a Callback into a C_Callback.

CellAllocCallback

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

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

type CellAllocCallback Source #

Arguments

= CellRenderer	`renderer`: the cell renderer to operate on
-> Rectangle	`cellArea`: the area allocated to `renderer` inside the rectangle provided to `cellAreaForeachAlloc`.
-> Rectangle	`cellBackground`: the background area for `renderer` inside the background area provided to `cellAreaForeachAlloc`.
-> IO Bool	Returns: `True` to stop iterating over cells.

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

type CellAllocCallback_WithClosures Source #

Arguments

= CellRenderer	`renderer`: the cell renderer to operate on
-> Rectangle	`cellArea`: the area allocated to `renderer` inside the rectangle provided to `cellAreaForeachAlloc`.
-> Rectangle	`cellBackground`: the background area for `renderer` inside the background area provided to `cellAreaForeachAlloc`.
-> Ptr ()	`data`: user-supplied data
-> IO Bool	Returns: `True` to stop iterating over cells.

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

drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CellAllocCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsCellRenderer a)
=> FunPtr C_CellAllocCallback
-> a	`renderer`: the cell renderer to operate on
-> Rectangle	`cellArea`: the area allocated to `renderer` inside the rectangle provided to `cellAreaForeachAlloc`.
-> Rectangle	`cellBackground`: the background area for `renderer` inside the background area provided to `cellAreaForeachAlloc`.
-> Ptr ()	`data`: user-supplied data
-> m Bool	Returns: `True` to stop iterating over cells.

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

genClosure_CellAllocCallback :: CellAllocCallback -> IO Closure Source #

Wrap the callback into a Closure.

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.

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

type CellCallback_WithClosures Source #

Arguments

= CellRenderer	`renderer`: the cell renderer to operate on
-> Ptr ()	`data`: user-supplied data
-> IO Bool	Returns: `True` to stop iterating over cells.

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

drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CellCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsCellRenderer a)
=> FunPtr C_CellCallback
-> a	`renderer`: the cell renderer to operate on
-> Ptr ()	`data`: user-supplied data
-> m Bool	Returns: `True` to stop iterating over cells.

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

genClosure_CellCallback :: CellCallback -> IO Closure Source #

Wrap the callback into a Closure.

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 `CellLayout`
-> CellRenderer	`cell`: the cell renderer whose value is to be set
-> TreeModel	`treeModel`: the model
-> TreeIter	`iter`: a `TreeIter` indicating the row to set the value for
-> IO ()

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

type CellLayoutDataFunc_WithClosures Source #

Arguments

= CellLayout	`cellLayout`: a `CellLayout`
-> CellRenderer	`cell`: the cell renderer whose value is to be set
-> TreeModel	`treeModel`: the model
-> TreeIter	`iter`: a `TreeIter` indicating the row to set the value for
-> Ptr ()	`data`: user data passed to `cellLayoutSetCellDataFunc`
-> IO ()

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

drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CellLayoutDataFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b, IsTreeModel c)
=> FunPtr C_CellLayoutDataFunc
-> a	`cellLayout`: a `CellLayout`
-> b	`cell`: the cell renderer whose value is to be set
-> c	`treeModel`: the model
-> TreeIter	`iter`: a `TreeIter` indicating the row to set the value for
-> Ptr ()	`data`: user data passed to `cellLayoutSetCellDataFunc`
-> m ()

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

genClosure_CellLayoutDataFunc :: CellLayoutDataFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

ClipboardClearFunc

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

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

type ClipboardClearFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Ptr ()	`userDataOrOwner`: the `userData` argument passed to `gtk_clipboard_set_with_data()`, or the `owner` argument passed to `gtk_clipboard_set_with_owner()`
-> IO ()

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

dynamic_ClipboardClearFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)
=> FunPtr C_ClipboardClearFunc
-> a	`clipboard`: the `Clipboard`
-> Ptr ()	`userDataOrOwner`: the `userData` argument passed to `gtk_clipboard_set_with_data()`, or the `owner` argument passed to `gtk_clipboard_set_with_owner()`
-> m ()

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

genClosure_ClipboardClearFunc :: ClipboardClearFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardClearFunc :: C_ClipboardClearFunc -> IO (FunPtr C_ClipboardClearFunc) Source #

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

noClipboardClearFunc :: Maybe ClipboardClearFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardClearFunc.

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

Wrap a ClipboardClearFunc into a C_ClipboardClearFunc.

ClipboardGetFunc

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

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

type ClipboardGetFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> SelectionData	`selectionData`: a `SelectionData` argument in which the requested data should be stored.
-> Word32	`info`: the info field corresponding to the requested target from the `TargetEntry` array passed to `gtk_clipboard_set_with_data()` or `gtk_clipboard_set_with_owner()`.
-> Ptr ()	`userDataOrOwner`: the `userData` argument passed to `gtk_clipboard_set_with_data()`, or the `owner` argument passed to `gtk_clipboard_set_with_owner()`
-> IO ()

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

dynamic_ClipboardGetFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)
=> FunPtr C_ClipboardGetFunc
-> a	`clipboard`: the `Clipboard`
-> SelectionData	`selectionData`: a `SelectionData` argument in which the requested data should be stored.
-> Word32	`info`: the info field corresponding to the requested target from the `TargetEntry` array passed to `gtk_clipboard_set_with_data()` or `gtk_clipboard_set_with_owner()`.
-> Ptr ()	`userDataOrOwner`: the `userData` argument passed to `gtk_clipboard_set_with_data()`, or the `owner` argument passed to `gtk_clipboard_set_with_owner()`
-> m ()

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

genClosure_ClipboardGetFunc :: ClipboardGetFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardGetFunc :: C_ClipboardGetFunc -> IO (FunPtr C_ClipboardGetFunc) Source #

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

noClipboardGetFunc :: Maybe ClipboardGetFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardGetFunc.

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

Wrap a ClipboardGetFunc into a C_ClipboardGetFunc.

ClipboardImageReceivedFunc

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

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

type ClipboardImageReceivedFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Pixbuf	`pixbuf`: the received image
-> IO ()

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

Since: 2.6

type ClipboardImageReceivedFunc_WithClosures Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Pixbuf	`pixbuf`: the received image
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestImage`.
-> IO ()

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

Since: 2.6

drop_closures_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> ClipboardImageReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardImageReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b)
=> FunPtr C_ClipboardImageReceivedFunc
-> a	`clipboard`: the `Clipboard`
-> b	`pixbuf`: the received image
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestImage`.
-> m ()

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

genClosure_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardImageReceivedFunc :: C_ClipboardImageReceivedFunc -> IO (FunPtr C_ClipboardImageReceivedFunc) Source #

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

noClipboardImageReceivedFunc :: Maybe ClipboardImageReceivedFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardImageReceivedFunc.

noClipboardImageReceivedFunc_WithClosures :: Maybe ClipboardImageReceivedFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ClipboardImageReceivedFunc_WithClosures.

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

Wrap a ClipboardImageReceivedFunc into a C_ClipboardImageReceivedFunc.

ClipboardReceivedFunc

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

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

type ClipboardReceivedFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> SelectionData	`selectionData`: a `SelectionData` containing the data was received. If retrieving the data failed, then then length field of `selectionData` will be negative.
-> IO ()

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

type ClipboardReceivedFunc_WithClosures Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> SelectionData	`selectionData`: a `SelectionData` containing the data was received. If retrieving the data failed, then then length field of `selectionData` will be negative.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestContents`.
-> IO ()

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

drop_closures_ClipboardReceivedFunc :: ClipboardReceivedFunc -> ClipboardReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)
=> FunPtr C_ClipboardReceivedFunc
-> a	`clipboard`: the `Clipboard`
-> SelectionData	`selectionData`: a `SelectionData` containing the data was received. If retrieving the data failed, then then length field of `selectionData` will be negative.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestContents`.
-> m ()

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

genClosure_ClipboardReceivedFunc :: ClipboardReceivedFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardReceivedFunc :: C_ClipboardReceivedFunc -> IO (FunPtr C_ClipboardReceivedFunc) Source #

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

noClipboardReceivedFunc :: Maybe ClipboardReceivedFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardReceivedFunc.

noClipboardReceivedFunc_WithClosures :: Maybe ClipboardReceivedFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ClipboardReceivedFunc_WithClosures.

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

Wrap a ClipboardReceivedFunc into a C_ClipboardReceivedFunc.

ClipboardRichTextReceivedFunc

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

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

type ClipboardRichTextReceivedFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Atom	`format`: The format of the rich text
-> Maybe Text	`text`: the rich text received, as a UTF-8 encoded string, or `Nothing` if retrieving the data failed.
-> Word64	`length`: Length of the text.
-> IO ()

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

Since: 2.10

type ClipboardRichTextReceivedFunc_WithClosures Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Atom	`format`: The format of the rich text
-> Maybe Text	`text`: the rich text received, as a UTF-8 encoded string, or `Nothing` if retrieving the data failed.
-> Word64	`length`: Length of the text.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestRichText`.
-> IO ()

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

Since: 2.10

drop_closures_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> ClipboardRichTextReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardRichTextReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)
=> FunPtr C_ClipboardRichTextReceivedFunc
-> a	`clipboard`: the `Clipboard`
-> Atom	`format`: The format of the rich text
-> Maybe Text	`text`: the rich text received, as a UTF-8 encoded string, or `Nothing` if retrieving the data failed.
-> Word64	`length`: Length of the text.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestRichText`.
-> m ()

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

genClosure_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardRichTextReceivedFunc :: C_ClipboardRichTextReceivedFunc -> IO (FunPtr C_ClipboardRichTextReceivedFunc) Source #

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

noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardRichTextReceivedFunc.

noClipboardRichTextReceivedFunc_WithClosures :: Maybe ClipboardRichTextReceivedFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ClipboardRichTextReceivedFunc_WithClosures.

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

Wrap a ClipboardRichTextReceivedFunc into a C_ClipboardRichTextReceivedFunc.

ClipboardTargetsReceivedFunc

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

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

type ClipboardTargetsReceivedFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Maybe [Atom]	`atoms`: the supported targets, as array of `Atom`, or `Nothing` if retrieving the data failed.
-> IO ()

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

Since: 2.4

type ClipboardTargetsReceivedFunc_WithClosures Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Maybe [Atom]	`atoms`: the supported targets, as array of `Atom`, or `Nothing` if retrieving the data failed.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestTargets`.
-> IO ()

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

Since: 2.4

drop_closures_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> ClipboardTargetsReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardTargetsReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)
=> FunPtr C_ClipboardTargetsReceivedFunc
-> a	`clipboard`: the `Clipboard`
-> Maybe [Atom]	`atoms`: the supported targets, as array of `Atom`, or `Nothing` if retrieving the data failed.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestTargets`.
-> m ()

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

genClosure_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardTargetsReceivedFunc :: C_ClipboardTargetsReceivedFunc -> IO (FunPtr C_ClipboardTargetsReceivedFunc) Source #

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

noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardTargetsReceivedFunc.

noClipboardTargetsReceivedFunc_WithClosures :: Maybe ClipboardTargetsReceivedFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ClipboardTargetsReceivedFunc_WithClosures.

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

Wrap a ClipboardTargetsReceivedFunc into a C_ClipboardTargetsReceivedFunc.

ClipboardTextReceivedFunc

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

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

type ClipboardTextReceivedFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Maybe Text	`text`: the text received, as a UTF-8 encoded string, or `Nothing` if retrieving the data failed.
-> IO ()

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

type ClipboardTextReceivedFunc_WithClosures Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> Maybe Text	`text`: the text received, as a UTF-8 encoded string, or `Nothing` if retrieving the data failed.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestText`.
-> IO ()

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

drop_closures_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> ClipboardTextReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardTextReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)
=> FunPtr C_ClipboardTextReceivedFunc
-> a	`clipboard`: the `Clipboard`
-> Maybe Text	`text`: the text received, as a UTF-8 encoded string, or `Nothing` if retrieving the data failed.
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestText`.
-> m ()

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

genClosure_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardTextReceivedFunc :: C_ClipboardTextReceivedFunc -> IO (FunPtr C_ClipboardTextReceivedFunc) Source #

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

noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardTextReceivedFunc.

noClipboardTextReceivedFunc_WithClosures :: Maybe ClipboardTextReceivedFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ClipboardTextReceivedFunc_WithClosures.

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

Wrap a ClipboardTextReceivedFunc into a C_ClipboardTextReceivedFunc.

ClipboardURIReceivedFunc

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

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

type ClipboardURIReceivedFunc Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> [Text]	`uris`: the received URIs
-> IO ()

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

Since: 2.14

type ClipboardURIReceivedFunc_WithClosures Source #

Arguments

= Clipboard	`clipboard`: the `Clipboard`
-> [Text]	`uris`: the received URIs
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestUris`.
-> IO ()

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

Since: 2.14

drop_closures_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> ClipboardURIReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardURIReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)
=> FunPtr C_ClipboardURIReceivedFunc
-> a	`clipboard`: the `Clipboard`
-> [Text]	`uris`: the received URIs
-> Ptr ()	`data`: the `userData` supplied to `clipboardRequestUris`.
-> m ()

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

genClosure_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ClipboardURIReceivedFunc :: C_ClipboardURIReceivedFunc -> IO (FunPtr C_ClipboardURIReceivedFunc) Source #

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

noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc Source #

A convenience synonym for Nothing :: Maybe ClipboardURIReceivedFunc.

noClipboardURIReceivedFunc_WithClosures :: Maybe ClipboardURIReceivedFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe ClipboardURIReceivedFunc_WithClosures.

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

Wrap a ClipboardURIReceivedFunc into a C_ClipboardURIReceivedFunc.

ColorSelectionChangePaletteFunc

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

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

type ColorSelectionChangePaletteFunc Source #

Arguments

= [Color]	`colors`: Array of colors
-> IO ()

Deprecated: (Since version 3.4)

No description available in the introspection data.

dynamic_ColorSelectionChangePaletteFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_ColorSelectionChangePaletteFunc
-> [Color]	`colors`: Array of colors
-> m ()

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

genClosure_ColorSelectionChangePaletteFunc :: ColorSelectionChangePaletteFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ColorSelectionChangePaletteFunc :: C_ColorSelectionChangePaletteFunc -> IO (FunPtr C_ColorSelectionChangePaletteFunc) Source #

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

noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc Source #

A convenience synonym for Nothing :: Maybe ColorSelectionChangePaletteFunc.

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

Wrap a ColorSelectionChangePaletteFunc into a C_ColorSelectionChangePaletteFunc.

ColorSelectionChangePaletteWithScreenFunc

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

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

type ColorSelectionChangePaletteWithScreenFunc Source #

Arguments

= Screen
-> [Color]	`colors`: Array of colors
-> IO ()

Deprecated: (Since version 3.4)

No description available in the introspection data.

Since: 2.2

dynamic_ColorSelectionChangePaletteWithScreenFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)
=> FunPtr C_ColorSelectionChangePaletteWithScreenFunc
-> a
-> [Color]	`colors`: Array of colors
-> m ()

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

genClosure_ColorSelectionChangePaletteWithScreenFunc :: ColorSelectionChangePaletteWithScreenFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ColorSelectionChangePaletteWithScreenFunc :: C_ColorSelectionChangePaletteWithScreenFunc -> IO (FunPtr C_ColorSelectionChangePaletteWithScreenFunc) Source #

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

noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc Source #

A convenience synonym for Nothing :: Maybe ColorSelectionChangePaletteWithScreenFunc.

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

Wrap a ColorSelectionChangePaletteWithScreenFunc into a C_ColorSelectionChangePaletteWithScreenFunc.

EntryCompletionMatchFunc

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

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

type EntryCompletionMatchFunc Source #

Arguments

= EntryCompletion	`completion`: the `EntryCompletion`
-> Text	`key`: the string to match, normalized and case-folded
-> TreeIter	`iter`: a `TreeIter` indicating the row to match
-> IO Bool	Returns: `True` if `iter` should be displayed as a possible completion for `key`

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

type EntryCompletionMatchFunc_WithClosures Source #

Arguments

= EntryCompletion	`completion`: the `EntryCompletion`
-> Text	`key`: the string to match, normalized and case-folded
-> TreeIter	`iter`: a `TreeIter` indicating the row to match
-> Ptr ()	`userData`: user data given to `entryCompletionSetMatchFunc`
-> IO Bool	Returns: `True` if `iter` should be displayed as a possible completion for `key`

A function which decides whether the row indicated by iter matches a given key, and should be displayed as a possible completion for key. Note that key is normalized and case-folded (see utf8Normalize and utf8Casefold). If this is not appropriate, match functions have access to the unmodified key via gtk_entry_get_text (GTK_ENTRY (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 `EntryCompletion`
-> Text	`key`: the string to match, normalized and case-folded
-> TreeIter	`iter`: a `TreeIter` indicating the row to match
-> Ptr ()	`userData`: user data given to `entryCompletionSetMatchFunc`
-> m Bool	Returns: `True` if `iter` should be displayed as a possible completion for `key`

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

genClosure_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

FileFilterFunc

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

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

type FileFilterFunc Source #

Arguments

= FileFilterInfo	`filterInfo`: a `FileFilterInfo` that is filled according to the `needed` flags passed to `fileFilterAddCustom`
-> IO Bool	Returns: `True` if the file should be displayed

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

type FileFilterFunc_WithClosures Source #

Arguments

= FileFilterInfo	`filterInfo`: a `FileFilterInfo` that is filled according to the `needed` flags passed to `fileFilterAddCustom`
-> Ptr ()	`data`: user data passed to `fileFilterAddCustom`
-> IO Bool	Returns: `True` if the file should be displayed

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

drop_closures_FileFilterFunc :: FileFilterFunc -> FileFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FileFilterFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_FileFilterFunc
-> FileFilterInfo	`filterInfo`: a `FileFilterInfo` that is filled according to the `needed` flags passed to `fileFilterAddCustom`
-> Ptr ()	`data`: user data passed to `fileFilterAddCustom`
-> m Bool	Returns: `True` if the file should be displayed

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

genClosure_FileFilterFunc :: FileFilterFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_FileFilterFunc :: C_FileFilterFunc -> IO (FunPtr C_FileFilterFunc) Source #

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

noFileFilterFunc :: Maybe FileFilterFunc Source #

A convenience synonym for Nothing :: Maybe FileFilterFunc.

noFileFilterFunc_WithClosures :: Maybe FileFilterFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe FileFilterFunc_WithClosures.

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

Wrap a FileFilterFunc into a C_FileFilterFunc.

FlowBoxCreateWidgetFunc

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

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

type FlowBoxCreateWidgetFunc Source #

Arguments

= Maybe Object	`item`: the item from the model for which to create a widget for
-> IO Widget	Returns: a `Widget` that represents `item`

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

Since: 3.18

type FlowBoxCreateWidgetFunc_WithClosures Source #

Arguments

= Maybe Object	`item`: the item from the model for which to create a widget for
-> Ptr ()	`userData`: user data from `flowBoxBindModel`
-> IO Widget	Returns: a `Widget` that represents `item`

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

Since: 3.18

drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxCreateWidgetFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a)
=> FunPtr C_FlowBoxCreateWidgetFunc
-> Maybe a	`item`: the item from the model for which to create a widget for
-> Ptr ()	`userData`: user data from `flowBoxBindModel`
-> m Widget	Returns: a `Widget` that represents `item`

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

genClosure_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `FlowBoxChild` that may be filtered
-> IO Bool	Returns: `True` if the row should be visible, `False` otherwise

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

Since: 3.12

type FlowBoxFilterFunc_WithClosures Source #

Arguments

= FlowBoxChild	`child`: a `FlowBoxChild` that may be filtered
-> Ptr ()	`userData`: user data
-> IO Bool	Returns: `True` if the row should be visible, `False` otherwise

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

Since: 3.12

drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxFilterFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsFlowBoxChild a)
=> FunPtr C_FlowBoxFilterFunc
-> a	`child`: a `FlowBoxChild` that may be filtered
-> Ptr ()	`userData`: user data
-> m Bool	Returns: `True` if the row should be visible, `False` otherwise

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

genClosure_FlowBoxFilterFunc :: FlowBoxFilterFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `FlowBox`
-> FlowBoxChild	`child`: a `FlowBoxChild`
-> IO ()

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

Since: 3.12

type FlowBoxForeachFunc_WithClosures Source #

Arguments

= FlowBox	`box`: a `FlowBox`
-> FlowBoxChild	`child`: a `FlowBoxChild`
-> Ptr ()	`userData`: user data
-> IO ()

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

Since: 3.12

drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b)
=> FunPtr C_FlowBoxForeachFunc
-> a	`box`: a `FlowBox`
-> b	`child`: a `FlowBoxChild`
-> Ptr ()	`userData`: user data
-> m ()

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

genClosure_FlowBoxForeachFunc :: FlowBoxForeachFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 the are equal, and > 0 otherwise

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

Since: 3.12

type FlowBoxSortFunc_WithClosures Source #

Arguments

= FlowBoxChild	`child1`: the first child
-> FlowBoxChild	`child2`: the second child
-> Ptr ()	`userData`: user data
-> IO Int32	Returns: < 0 if `child1` should be before `child2`, 0 if the are equal, and > 0 otherwise

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

Since: 3.12

drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxSortFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsFlowBoxChild a, IsFlowBoxChild b)
=> FunPtr C_FlowBoxSortFunc
-> a	`child1`: the first child
-> b	`child2`: the second child
-> Ptr ()	`userData`: user data
-> m Int32	Returns: < 0 if `child1` should be before `child2`, 0 if the are equal, and > 0 otherwise

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

genClosure_FlowBoxSortFunc :: FlowBoxSortFunc -> IO Closure Source #

Wrap the callback into a Closure.

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

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

type FontFilterFunc_WithClosures Source #

Arguments

= FontFamily	`family`: a `FontFamily`
-> FontFace	`face`: a `FontFace` belonging to `family`
-> Ptr ()	`data`: user data passed to `fontChooserSetFilterFunc`
-> IO Bool	Returns: `True` if the font should be displayed

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

drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FontFilterFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsFontFamily a, IsFontFace b)
=> FunPtr C_FontFilterFunc
-> a	`family`: a `FontFamily`
-> b	`face`: a `FontFace` belonging to `family`
-> Ptr ()	`data`: user data passed to `fontChooserSetFilterFunc`
-> m Bool	Returns: `True` if the font should be displayed

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

genClosure_FontFilterFunc :: FontFilterFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `IconView`
-> TreePath	`path`: The `TreePath` of a selected row
-> IO ()

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

type IconViewForeachFunc_WithClosures Source #

Arguments

= IconView	`iconView`: a `IconView`
-> TreePath	`path`: The `TreePath` of a selected row
-> Ptr ()	`data`: user data
-> IO ()

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

drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_IconViewForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsIconView a)
=> FunPtr C_IconViewForeachFunc
-> a	`iconView`: a `IconView`
-> TreePath	`path`: The `TreePath` of a selected row
-> Ptr ()	`data`: user data
-> m ()

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

genClosure_IconViewForeachFunc :: IconViewForeachFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

KeySnoopFunc

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

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

type KeySnoopFunc Source #

Arguments

= Widget	`grabWidget`: the widget to which the event will be delivered
-> EventKey	`event`: the key event
-> IO Int32	Returns: `True` to stop further processing of `event`, `False` to continue.

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

type KeySnoopFunc_WithClosures Source #

Arguments

= Widget	`grabWidget`: the widget to which the event will be delivered
-> EventKey	`event`: the key event
-> Ptr ()	`funcData`: data supplied to `gtk_key_snooper_install()`
-> IO Int32	Returns: `True` to stop further processing of `event`, `False` to continue.

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

drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_KeySnoopFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)
=> FunPtr C_KeySnoopFunc
-> a	`grabWidget`: the widget to which the event will be delivered
-> EventKey	`event`: the key event
-> Ptr ()	`funcData`: data supplied to `gtk_key_snooper_install()`
-> m Int32	Returns: `True` to stop further processing of `event`, `False` to continue.

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

genClosure_KeySnoopFunc :: KeySnoopFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc) Source #

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

noKeySnoopFunc :: Maybe KeySnoopFunc Source #

A convenience synonym for Nothing :: Maybe KeySnoopFunc.

noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe KeySnoopFunc_WithClosures.

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

Wrap a KeySnoopFunc into a C_KeySnoopFunc.

ListBoxCreateWidgetFunc

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

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

type ListBoxCreateWidgetFunc Source #

Arguments

= Object	`item`: the item from the model for which to create a widget for
-> IO Widget	Returns: a `Widget` that represents `item`

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

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

Since: 3.16

type ListBoxCreateWidgetFunc_WithClosures Source #

Arguments

= Object	`item`: the item from the model for which to create a widget for
-> Ptr ()	`userData`: user data
-> IO Widget	Returns: a `Widget` that represents `item`

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

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

Since: 3.16

drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures 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 `Widget` that represents `item`

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

genClosure_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

Since: 3.10

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.

Since: 3.10

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 :: ListBoxFilterFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `ListBox`
-> ListBoxRow	`row`: a `ListBoxRow`
-> IO ()

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

Since: 3.14

type ListBoxForeachFunc_WithClosures Source #

Arguments

= ListBox	`box`: a `ListBox`
-> ListBoxRow	`row`: a `ListBoxRow`
-> Ptr ()	`userData`: user data
-> IO ()

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

Since: 3.14

drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b)
=> FunPtr C_ListBoxForeachFunc
-> a	`box`: a `ListBox`
-> b	`row`: a `ListBoxRow`
-> Ptr ()	`userData`: user data
-> m ()

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

genClosure_ListBoxForeachFunc :: ListBoxForeachFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

Since: 3.10

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.

Since: 3.10

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 :: ListBoxSortFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

Since: 3.10

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.

Since: 3.10

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 :: ListBoxUpdateHeaderFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

MenuDetachFunc

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

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

type MenuDetachFunc Source #

Arguments

= Widget	`attachWidget`: the `Widget` that the menu is being detached from.
-> Menu	`menu`: the `Menu` being detached.
-> IO ()

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

dynamic_MenuDetachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsMenu b)
=> FunPtr C_MenuDetachFunc
-> a	`attachWidget`: the `Widget` that the menu is being detached from.
-> b	`menu`: the `Menu` being detached.
-> m ()

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

genClosure_MenuDetachFunc :: MenuDetachFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_MenuDetachFunc :: C_MenuDetachFunc -> IO (FunPtr C_MenuDetachFunc) Source #

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

noMenuDetachFunc :: Maybe MenuDetachFunc Source #

A convenience synonym for Nothing :: Maybe MenuDetachFunc.

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

Wrap a MenuDetachFunc into a C_MenuDetachFunc.

MenuPositionFunc

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

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

type MenuPositionFunc Source #

Arguments

= Menu	`menu`: a `Menu`.
-> Int32	`x`: address of the `gint` representing the horizontal position where the menu shall be drawn.
-> Int32	`y`: address of the `gint` representing the vertical position where the menu shall be drawn. This is an output parameter.
-> IO (Int32, Int32, Bool)

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

type MenuPositionFunc_WithClosures Source #

Arguments

= Menu	`menu`: a `Menu`.
-> Int32	`x`: address of the `gint` representing the horizontal position where the menu shall be drawn.
-> Int32	`y`: address of the `gint` representing the vertical position where the menu shall be drawn. This is an output parameter.
-> Ptr ()	`userData`: the data supplied by the user in the `menuPopup` `data` parameter.
-> IO (Int32, Int32, Bool)

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

drop_closures_MenuPositionFunc :: MenuPositionFunc -> MenuPositionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MenuPositionFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsMenu a)
=> FunPtr C_MenuPositionFunc
-> a	`menu`: a `Menu`.
-> Int32	`x`: address of the `gint` representing the horizontal position where the menu shall be drawn.
-> Int32	`y`: address of the `gint` representing the vertical position where the menu shall be drawn. This is an output parameter.
-> Ptr ()	`userData`: the data supplied by the user in the `menuPopup` `data` parameter.
-> m (Int32, Int32, Bool)

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

genClosure_MenuPositionFunc :: MenuPositionFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_MenuPositionFunc :: C_MenuPositionFunc -> IO (FunPtr C_MenuPositionFunc) Source #

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

noMenuPositionFunc :: Maybe MenuPositionFunc Source #

A convenience synonym for Nothing :: Maybe MenuPositionFunc.

noMenuPositionFunc_WithClosures :: Maybe MenuPositionFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe MenuPositionFunc_WithClosures.

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

Wrap a MenuPositionFunc into a C_MenuPositionFunc.

ModuleDisplayInitFunc

type C_ModuleDisplayInitFunc = Ptr Display -> IO () Source #

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

type ModuleDisplayInitFunc Source #

Arguments

= Display	`display`: an open `Display`
-> IO ()

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

Since: 2.2

dynamic_ModuleDisplayInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDisplay a)
=> FunPtr C_ModuleDisplayInitFunc
-> a	`display`: an open `Display`
-> m ()

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

genClosure_ModuleDisplayInitFunc :: ModuleDisplayInitFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ModuleDisplayInitFunc :: C_ModuleDisplayInitFunc -> IO (FunPtr C_ModuleDisplayInitFunc) Source #

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

noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc Source #

A convenience synonym for Nothing :: Maybe ModuleDisplayInitFunc.

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

Wrap a ModuleDisplayInitFunc into a C_ModuleDisplayInitFunc.

ModuleInitFunc

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

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

type ModuleInitFunc Source #

Arguments

= Maybe [Text]	`argv`: GTK+ always passes `Nothing` for this argument
-> IO ()

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

dynamic_ModuleInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_ModuleInitFunc
-> Maybe [Text]	`argv`: GTK+ always passes `Nothing` for this argument
-> m ()

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

genClosure_ModuleInitFunc :: ModuleInitFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_ModuleInitFunc :: C_ModuleInitFunc -> IO (FunPtr C_ModuleInitFunc) Source #

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

noModuleInitFunc :: Maybe ModuleInitFunc Source #

A convenience synonym for Nothing :: Maybe ModuleInitFunc.

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

Wrap a ModuleInitFunc into a C_ModuleInitFunc.

PageSetupDoneFunc

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

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

type PageSetupDoneFunc Source #

Arguments

= PageSetup	`pageSetup`: the `PageSetup` that has been
-> IO ()

The type of function that is passed to printRunPageSetupDialogAsync.

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

type PageSetupDoneFunc_WithClosures Source #

Arguments

= PageSetup	`pageSetup`: the `PageSetup` that has been
-> Ptr ()	`data`: user data that has been passed to `printRunPageSetupDialogAsync`
-> IO ()

The type of function that is passed to printRunPageSetupDialogAsync.

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

drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_PageSetupDoneFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsPageSetup a)
=> FunPtr C_PageSetupDoneFunc
-> a	`pageSetup`: the `PageSetup` that has been
-> 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 :: PageSetupDoneFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

PrintSettingsFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_PrintSettingsFunc :: PrintSettingsFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

RcPropertyParser

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

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

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

No description available in the introspection data.

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

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

genClosure_RcPropertyParser :: RcPropertyParser -> IO Closure Source #

Wrap the callback into a Closure.

mk_RcPropertyParser :: C_RcPropertyParser -> IO (FunPtr C_RcPropertyParser) Source #

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

noRcPropertyParser :: Maybe RcPropertyParser Source #

A convenience synonym for Nothing :: Maybe RcPropertyParser.

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

Wrap a RcPropertyParser into a C_RcPropertyParser.

RecentFilterFunc

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

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

type RecentFilterFunc Source #

Arguments

= RecentFilterInfo	`filterInfo`: a `RecentFilterInfo` that is filled according to the `needed` flags passed to `recentFilterAddCustom`
-> IO Bool	Returns: `True` if the file should be displayed

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

type RecentFilterFunc_WithClosures Source #

Arguments

= RecentFilterInfo	`filterInfo`: a `RecentFilterInfo` that is filled according to the `needed` flags passed to `recentFilterAddCustom`
-> Ptr ()	`userData`: user data passed to `recentFilterAddCustom`
-> IO Bool	Returns: `True` if the file should be displayed

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

drop_closures_RecentFilterFunc :: RecentFilterFunc -> RecentFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_RecentFilterFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_RecentFilterFunc
-> RecentFilterInfo	`filterInfo`: a `RecentFilterInfo` that is filled according to the `needed` flags passed to `recentFilterAddCustom`
-> Ptr ()	`userData`: user data passed to `recentFilterAddCustom`
-> m Bool	Returns: `True` if the file should be displayed

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

genClosure_RecentFilterFunc :: RecentFilterFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_RecentFilterFunc :: C_RecentFilterFunc -> IO (FunPtr C_RecentFilterFunc) Source #

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

noRecentFilterFunc :: Maybe RecentFilterFunc Source #

A convenience synonym for Nothing :: Maybe RecentFilterFunc.

noRecentFilterFunc_WithClosures :: Maybe RecentFilterFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe RecentFilterFunc_WithClosures.

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

Wrap a RecentFilterFunc into a C_RecentFilterFunc.

RecentSortFunc

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

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

type RecentSortFunc = RecentInfo -> RecentInfo -> IO Int32 Source #

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_RecentSortFunc :: RecentSortFunc -> RecentSortFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_RecentSortFunc :: RecentSortFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_RecentSortFunc :: C_RecentSortFunc -> IO (FunPtr C_RecentSortFunc) Source #

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

noRecentSortFunc :: Maybe RecentSortFunc Source #

A convenience synonym for Nothing :: Maybe RecentSortFunc.

noRecentSortFunc_WithClosures :: Maybe RecentSortFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe RecentSortFunc_WithClosures.

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

Wrap a RecentSortFunc into a C_RecentSortFunc.

StylePropertyParser

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

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

type StylePropertyParser Source #

Arguments

= Text
-> GValue
-> IO ()	(Can throw `GError`)

No description available in the introspection data.

dynamic_StylePropertyParser Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_StylePropertyParser
-> Text
-> GValue
-> m ()	(Can throw `GError`)

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

mk_StylePropertyParser :: C_StylePropertyParser -> IO (FunPtr C_StylePropertyParser) Source #

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

noStylePropertyParser :: Maybe StylePropertyParser Source #

A convenience synonym for Nothing :: Maybe StylePropertyParser.

TextBufferDeserializeFunc

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

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

type TextBufferDeserializeFunc Source #

Arguments

= TextBuffer	`registerBuffer`: the `TextBuffer` the format is registered with
-> TextBuffer	`contentBuffer`: the `TextBuffer` to deserialize into
-> TextIter	`iter`: insertion point for the deserialized text
-> ByteString	`data`: data to deserialize
-> Bool	`createTags`: `True` if deserializing may create tags
-> IO ()	Returns: `True` on success, `False` otherwise (Can throw `GError`)

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

type TextBufferDeserializeFunc_WithClosures Source #

Arguments

= TextBuffer	`registerBuffer`: the `TextBuffer` the format is registered with
-> TextBuffer	`contentBuffer`: the `TextBuffer` to deserialize into
-> TextIter	`iter`: insertion point for the deserialized text
-> ByteString	`data`: data to deserialize
-> Bool	`createTags`: `True` if deserializing may create tags
-> Ptr ()	`userData`: user data that was specified when registering the format
-> IO ()	Returns: `True` on success, `False` otherwise (Can throw `GError`)

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

drop_closures_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> TextBufferDeserializeFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextBufferDeserializeFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b)
=> FunPtr C_TextBufferDeserializeFunc
-> a	`registerBuffer`: the `TextBuffer` the format is registered with
-> b	`contentBuffer`: the `TextBuffer` to deserialize into
-> TextIter	`iter`: insertion point for the deserialized text
-> ByteString	`data`: data to deserialize
-> Bool	`createTags`: `True` if deserializing may create tags
-> Ptr ()	`userData`: user data that was specified when registering the format
-> m ()	(Can throw `GError`)

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

mk_TextBufferDeserializeFunc :: C_TextBufferDeserializeFunc -> IO (FunPtr C_TextBufferDeserializeFunc) Source #

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

noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc Source #

A convenience synonym for Nothing :: Maybe TextBufferDeserializeFunc.

noTextBufferDeserializeFunc_WithClosures :: Maybe TextBufferDeserializeFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TextBufferDeserializeFunc_WithClosures.

TextBufferSerializeFunc

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

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

type TextBufferSerializeFunc Source #

Arguments

= TextBuffer	`registerBuffer`: the `TextBuffer` for which the format is registered
-> TextBuffer	`contentBuffer`: the `TextBuffer` to serialize
-> TextIter	`start`: start of the block of text to serialize
-> TextIter	`end`: end of the block of text to serialize
-> Word64	`length`: Return location for the length of the serialized data
-> IO Word8	Returns: a newly-allocated array of guint8 which contains the serialized data, or `Nothing` if an error occurred

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

type TextBufferSerializeFunc_WithClosures Source #

Arguments

= TextBuffer	`registerBuffer`: the `TextBuffer` for which the format is registered
-> TextBuffer	`contentBuffer`: the `TextBuffer` to serialize
-> TextIter	`start`: start of the block of text to serialize
-> TextIter	`end`: end of the block of text to serialize
-> Word64	`length`: Return location for the length of the serialized data
-> Ptr ()	`userData`: user data that was specified when registering the format
-> IO Word8	Returns: a newly-allocated array of guint8 which contains the serialized data, or `Nothing` if an error occurred

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

drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextBufferSerializeFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b)
=> FunPtr C_TextBufferSerializeFunc
-> a	`registerBuffer`: the `TextBuffer` for which the format is registered
-> b	`contentBuffer`: the `TextBuffer` to serialize
-> TextIter	`start`: start of the block of text to serialize
-> TextIter	`end`: end of the block of text to serialize
-> Word64	`length`: Return location for the length of the serialized data
-> Ptr ()	`userData`: user data that was specified when registering the format
-> m Word8	Returns: a newly-allocated array of guint8 which contains the serialized data, or `Nothing` if an error occurred

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

genClosure_TextBufferSerializeFunc :: TextBufferSerializeFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_TextBufferSerializeFunc :: C_TextBufferSerializeFunc -> IO (FunPtr C_TextBufferSerializeFunc) Source #

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

noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc Source #

A convenience synonym for Nothing :: Maybe TextBufferSerializeFunc.

noTextBufferSerializeFunc_WithClosures :: Maybe TextBufferSerializeFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TextBufferSerializeFunc_WithClosures.

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

Wrap a TextBufferSerializeFunc into a C_TextBufferSerializeFunc.

TextCharPredicate

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

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

type TextCharPredicate = Char -> IO Bool Source #

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_TextCharPredicate :: TextCharPredicate -> IO Closure Source #

Wrap the callback into a Closure.

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

No description available in the introspection data.

type TextTagTableForeach_WithClosures Source #

Arguments

= TextTag	`tag`: the `TextTag`
-> Ptr ()	`data`: data passed to `textTagTableForeach`
-> IO ()

No description available in the introspection data.

drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextTagTableForeach Source #

Arguments

:: (HasCallStack, MonadIO m, IsTextTag a)
=> FunPtr C_TextTagTableForeach
-> a	`tag`: the `TextTag`
-> Ptr ()	`data`: data passed to `textTagTableForeach`
-> m ()

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

genClosure_TextTagTableForeach :: TextTagTableForeach -> IO Closure Source #

Wrap the callback into a Closure.

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 (same as calling `widgetGetFrameClock`)
-> IO Bool	Returns: `SOURCE_CONTINUE` if the tick callback should continue to be called, `SOURCE_REMOVE` if the tick callback should be removed.

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

Since: 3.8

type TickCallback_WithClosures Source #

Arguments

= Widget	`widget`: the widget
-> FrameClock	`frameClock`: the frame clock for the widget (same as calling `widgetGetFrameClock`)
-> Ptr ()	`userData`: user data passed to `widgetAddTickCallback`.
-> IO Bool	Returns: `SOURCE_CONTINUE` if the tick callback should continue to be called, `SOURCE_REMOVE` if the tick callback should be removed.

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

Since: 3.8

drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TickCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsFrameClock b)
=> FunPtr C_TickCallback
-> a	`widget`: the widget
-> b	`frameClock`: the frame clock for the widget (same as calling `widgetGetFrameClock`)
-> Ptr ()	`userData`: user data passed to `widgetAddTickCallback`.
-> m Bool	Returns: `SOURCE_CONTINUE` if the tick callback should continue to be called, `SOURCE_REMOVE` if the tick callback should be removed.

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

genClosure_TickCallback :: TickCallback -> IO Closure Source #

Wrap the callback into a Closure.

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.

TranslateFunc

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

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

type TranslateFunc Source #

Arguments

= Text	`path`: The id of the message. In `ActionGroup` this will be a label or tooltip from a `ActionEntry`.
-> IO Text	Returns: the translated message

Deprecated: (Since version 3.10)

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

type TranslateFunc_WithClosures Source #

Arguments

= Text	`path`: The id of the message. In `ActionGroup` this will be a label or tooltip from a `ActionEntry`.
-> Ptr ()	`funcData`: user data passed in when registering the function
-> IO Text	Returns: the translated message

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

drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TranslateFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_TranslateFunc
-> Text	`path`: The id of the message. In `ActionGroup` this will be a label or tooltip from a `ActionEntry`.
-> Ptr ()	`funcData`: user data passed in when registering the function
-> m Text	Returns: the translated message

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

genClosure_TranslateFunc :: TranslateFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc) Source #

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

noTranslateFunc :: Maybe TranslateFunc Source #

A convenience synonym for Nothing :: Maybe TranslateFunc.

noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TranslateFunc_WithClosures.

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

Wrap a TranslateFunc into a C_TranslateFunc.

TreeCellDataFunc

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

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

type TreeCellDataFunc Source #

Arguments

= TreeViewColumn	`treeColumn`: A `TreeViewColumn`
-> CellRenderer	`cell`: The `CellRenderer` that is being rendered by `treeColumn`
-> TreeModel	`treeModel`: The `TreeModel` being rendered
-> TreeIter	`iter`: A `TreeIter` of the current row rendered
-> IO ()

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

type TreeCellDataFunc_WithClosures Source #

Arguments

= TreeViewColumn	`treeColumn`: A `TreeViewColumn`
-> CellRenderer	`cell`: The `CellRenderer` that is being rendered by `treeColumn`
-> TreeModel	`treeModel`: The `TreeModel` being rendered
-> TreeIter	`iter`: A `TreeIter` of the current row rendered
-> Ptr ()	`data`: user data
-> IO ()

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

drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeCellDataFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b, IsTreeModel c)
=> FunPtr C_TreeCellDataFunc
-> a	`treeColumn`: A `TreeViewColumn`
-> b	`cell`: The `CellRenderer` that is being rendered by `treeColumn`
-> c	`treeModel`: The `TreeModel` being rendered
-> TreeIter	`iter`: A `TreeIter` of the current row rendered
-> Ptr ()	`data`: user data
-> m ()

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

genClosure_TreeCellDataFunc :: TreeCellDataFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

TreeDestroyCountFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TreeDestroyCountFunc :: TreeDestroyCountFunc -> TreeDestroyCountFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_TreeDestroyCountFunc :: TreeDestroyCountFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_TreeDestroyCountFunc :: C_TreeDestroyCountFunc -> IO (FunPtr C_TreeDestroyCountFunc) Source #

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

noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc Source #

A convenience synonym for Nothing :: Maybe TreeDestroyCountFunc.

noTreeDestroyCountFunc_WithClosures :: Maybe TreeDestroyCountFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeDestroyCountFunc_WithClosures.

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

Wrap a TreeDestroyCountFunc into a C_TreeDestroyCountFunc.

TreeIterCompareFunc

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

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

type TreeIterCompareFunc Source #

Arguments

= TreeModel	`model`: The `TreeModel` the comparison is within
-> TreeIter	`a`: A `TreeIter` in `model`
-> TreeIter	`b`: Another `TreeIter` in `model`
-> IO Int32	Returns: a negative integer, zero or a positive integer depending on whether `a` sorts before, with or after `b`

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

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

type TreeIterCompareFunc_WithClosures Source #

Arguments

= TreeModel	`model`: The `TreeModel` the comparison is within
-> TreeIter	`a`: A `TreeIter` in `model`
-> TreeIter	`b`: Another `TreeIter` in `model`
-> Ptr ()	`userData`: Data passed when the compare func is assigned e.g. by `treeSortableSetSortFunc`
-> IO Int32	Returns: a negative integer, zero or a positive integer depending on whether `a` sorts before, with or after `b`

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

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

drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeIterCompareFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a)
=> FunPtr C_TreeIterCompareFunc
-> a	`model`: The `TreeModel` the comparison is within
-> TreeIter	`a`: A `TreeIter` in `model`
-> TreeIter	`b`: Another `TreeIter` in `model`
-> Ptr ()	`userData`: Data passed when the compare func is assigned e.g. by `treeSortableSetSortFunc`
-> m Int32	Returns: a negative integer, zero or a positive integer depending on whether `a` sorts before, with or after `b`

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

genClosure_TreeIterCompareFunc :: TreeIterCompareFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

TreeModelFilterVisibleFunc

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

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

type TreeModelFilterVisibleFunc Source #

Arguments

= TreeModel	`model`: the child model of the `TreeModelFilter`
-> TreeIter	`iter`: a `TreeIter` pointing to the row in `model` whose visibility is determined
-> IO Bool	Returns: Whether the row indicated by `iter` is visible.

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

type TreeModelFilterVisibleFunc_WithClosures Source #

Arguments

= TreeModel	`model`: the child model of the `TreeModelFilter`
-> TreeIter	`iter`: a `TreeIter` pointing to the row in `model` whose visibility is determined
-> Ptr ()	`data`: user data given to `treeModelFilterSetVisibleFunc`
-> IO Bool	Returns: Whether the row indicated by `iter` is visible.

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

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 `TreeModelFilter`
-> TreeIter	`iter`: a `TreeIter` pointing to the row in `model` whose visibility is determined
-> Ptr ()	`data`: user data given to `treeModelFilterSetVisibleFunc`
-> m Bool	Returns: Whether the row indicated by `iter` is visible.

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

genClosure_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> IO Closure Source #

Wrap the callback into a Closure.

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

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

type TreeModelForeachFunc_WithClosures Source #

Arguments

= TreeModel	`model`: the `TreeModel` being iterated
-> TreePath	`path`: the current `TreePath`
-> TreeIter	`iter`: the current `TreeIter`
-> Ptr ()	`data`: The user data passed to `treeModelForeach`
-> IO Bool	Returns: `True` to stop iterating, `False` to continue

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

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 `TreeModel` being iterated
-> TreePath	`path`: the current `TreePath`
-> TreeIter	`iter`: the current `TreeIter`
-> Ptr ()	`data`: The user data passed to `treeModelForeach`
-> m Bool	Returns: `True` to stop iterating, `False` to continue

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

genClosure_TreeModelForeachFunc :: TreeModelForeachFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `TreeModel` being viewed
-> TreePath	`path`: The `TreePath` of a selected row
-> TreeIter	`iter`: A `TreeIter` pointing to a selected row
-> IO ()

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

type TreeSelectionForeachFunc_WithClosures Source #

Arguments

= TreeModel	`model`: The `TreeModel` being viewed
-> TreePath	`path`: The `TreePath` of a selected row
-> TreeIter	`iter`: A `TreeIter` pointing to a selected row
-> Ptr ()	`data`: user data
-> IO ()

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

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 `TreeModel` being viewed
-> TreePath	`path`: The `TreePath` of a selected row
-> TreeIter	`iter`: A `TreeIter` pointing to a selected row
-> Ptr ()	`data`: user data
-> m ()

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

genClosure_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `TreeSelection`
-> TreeModel	`model`: A `TreeModel` being viewed
-> TreePath	`path`: The `TreePath` of the row in question
-> Bool	`pathCurrentlySelected`: `True`, if the path is currently selected
-> IO Bool	Returns: `True`, if the selection state of the row can be toggled

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

type TreeSelectionFunc_WithClosures Source #

Arguments

= TreeSelection	`selection`: A `TreeSelection`
-> TreeModel	`model`: A `TreeModel` being viewed
-> TreePath	`path`: The `TreePath` of the row in question
-> Bool	`pathCurrentlySelected`: `True`, if the path is currently selected
-> Ptr ()	`data`: user data
-> IO Bool	Returns: `True`, if the selection state of the row can be toggled

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

drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeSelectionFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b)
=> FunPtr C_TreeSelectionFunc
-> a	`selection`: A `TreeSelection`
-> b	`model`: A `TreeModel` being viewed
-> TreePath	`path`: The `TreePath` of the row in question
-> Bool	`pathCurrentlySelected`: `True`, if the path is currently selected
-> Ptr ()	`data`: user data
-> m Bool	Returns: `True`, if the selection state of the row can be toggled

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

genClosure_TreeSelectionFunc :: TreeSelectionFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `TreeView`
-> TreeViewColumn	`column`: The `TreeViewColumn` being dragged
-> TreeViewColumn	`prevColumn`: A `TreeViewColumn` on one side of `column`
-> TreeViewColumn	`nextColumn`: A `TreeViewColumn` on the other side of `column`
-> IO Bool	Returns: `True`, if `column` can be dropped in this spot

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

type TreeViewColumnDropFunc_WithClosures Source #

Arguments

= TreeView	`treeView`: A `TreeView`
-> TreeViewColumn	`column`: The `TreeViewColumn` being dragged
-> TreeViewColumn	`prevColumn`: A `TreeViewColumn` on one side of `column`
-> TreeViewColumn	`nextColumn`: A `TreeViewColumn` on the other side of `column`
-> Ptr ()	`data`: user data
-> IO Bool	Returns: `True`, if `column` can be dropped in this spot

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

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 `TreeView`
-> b	`column`: The `TreeViewColumn` being dragged
-> c	`prevColumn`: A `TreeViewColumn` on one side of `column`
-> d	`nextColumn`: A `TreeViewColumn` on the other side of `column`
-> Ptr ()	`data`: user data
-> m Bool	Returns: `True`, if `column` can be dropped in this spot

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

genClosure_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> IO Closure Source #

Wrap the callback into a Closure.

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

Function used for treeViewMapExpandedRows.

type TreeViewMappingFunc_WithClosures Source #

Arguments

= TreeView	`treeView`: A `TreeView`
-> TreePath	`path`: The path that’s expanded
-> Ptr ()	`userData`: user data
-> IO ()

Function used for treeViewMapExpandedRows.

drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewMappingFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeView a)
=> FunPtr C_TreeViewMappingFunc
-> a	`treeView`: A `TreeView`
-> TreePath	`path`: The path that’s expanded
-> Ptr ()	`userData`: user data
-> m ()

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

genClosure_TreeViewMappingFunc :: TreeViewMappingFunc -> IO Closure Source #

Wrap the callback into a Closure.

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

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

type TreeViewRowSeparatorFunc_WithClosures Source #

Arguments

= TreeModel	`model`: the `TreeModel`
-> TreeIter	`iter`: a `TreeIter` pointing at a row in `model`
-> Ptr ()	`data`: user data
-> IO Bool	Returns: `True` if the row is a separator

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

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 `TreeModel`
-> TreeIter	`iter`: a `TreeIter` pointing at a row in `model`
-> Ptr ()	`data`: user data
-> m Bool	Returns: `True` if the row is a separator

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

genClosure_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> IO Closure Source #

Wrap the callback into a Closure.

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 `TreeModel` being searched
-> Int32	`column`: the search column set by `treeViewSetSearchColumn`
-> Text	`key`: the key string to compare with
-> TreeIter	`iter`: a `TreeIter` pointing the row of `model` that should be compared with `key`.
-> IO Bool	Returns: `False` if the row matches, `True` otherwise.

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

type TreeViewSearchEqualFunc_WithClosures Source #

Arguments

= TreeModel	`model`: the `TreeModel` being searched
-> Int32	`column`: the search column set by `treeViewSetSearchColumn`
-> Text	`key`: the key string to compare with
-> TreeIter	`iter`: a `TreeIter` pointing the row of `model` that should be compared with `key`.
-> Ptr ()	`searchData`: user data from `treeViewSetSearchEqualFunc`
-> IO Bool	Returns: `False` if the row matches, `True` otherwise.

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

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 `TreeModel` being searched
-> Int32	`column`: the search column set by `treeViewSetSearchColumn`
-> Text	`key`: the key string to compare with
-> TreeIter	`iter`: a `TreeIter` pointing the row of `model` that should be compared with `key`.
-> Ptr ()	`searchData`: user data from `treeViewSetSearchEqualFunc`
-> m Bool	Returns: `False` if the row matches, `True` otherwise.

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

genClosure_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> IO Closure Source #

Wrap the callback into a Closure.

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.

TreeViewSearchPositionFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> TreeViewSearchPositionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> IO Closure Source #

Wrap the callback into a Closure.

mk_TreeViewSearchPositionFunc :: C_TreeViewSearchPositionFunc -> IO (FunPtr C_TreeViewSearchPositionFunc) Source #

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

noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc Source #

A convenience synonym for Nothing :: Maybe TreeViewSearchPositionFunc.

noTreeViewSearchPositionFunc_WithClosures :: Maybe TreeViewSearchPositionFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe TreeViewSearchPositionFunc_WithClosures.

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

Wrap a TreeViewSearchPositionFunc into a C_TreeViewSearchPositionFunc.