GI.Gtk.Callbacks

Signals

AccelGroupActivate

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

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

dynamic_AccelGroupActivate :: (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 -> Ptr AccelGroup -> Ptr Object -> Word32 -> CUInt -> IO CInt

AccelGroupFindFunc

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 :: 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 -> Ptr AccelKey -> Ptr Closure -> Ptr () -> IO CInt

AccelMapForeach

type AccelMapForeach = Ptr () -> Text -> Word32 -> [ModifierType] -> Bool -> IO ()

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

dynamic_AccelMapForeach :: 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 -> Ptr () -> CString -> Word32 -> CUInt -> CInt -> IO ()

AssistantPageFunc

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 :: 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 -> Int32 -> Ptr () -> IO Int32

BuilderConnectFunc

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 :: (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 -> Ptr Builder -> Ptr Object -> CString -> CString -> Ptr Object -> CUInt -> Ptr () -> IO ()

CalendarDetailFunc

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 :: (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 -> Ptr Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO CString

Callback

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 :: (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 -> Ptr Widget -> Ptr () -> IO ()

CellAllocCallback

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 :: (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 -> Ptr CellRenderer -> Ptr Rectangle -> Ptr Rectangle -> Ptr () -> IO CInt

CellCallback

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 :: (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 -> Ptr CellRenderer -> Ptr () -> IO CInt

CellLayoutDataFunc

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 :: (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 -> Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

ClipboardClearFunc

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

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

dynamic_ClipboardClearFunc :: (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 -> Ptr Clipboard -> Ptr () -> IO ()

ClipboardGetFunc

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

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

dynamic_ClipboardGetFunc :: (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 -> Ptr Clipboard -> Ptr SelectionData -> Word32 -> Ptr () -> IO ()

ClipboardImageReceivedFunc

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 :: (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 -> Ptr Clipboard -> Ptr Pixbuf -> Ptr () -> IO ()

ClipboardReceivedFunc

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 :: (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 -> Ptr Clipboard -> Ptr SelectionData -> Ptr () -> IO ()

ClipboardRichTextReceivedFunc

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 :: (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 -> Ptr Clipboard -> Ptr Atom -> CString -> Word64 -> Ptr () -> IO ()

ClipboardTargetsReceivedFunc

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 :: (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 -> Ptr Clipboard -> Ptr (Ptr Atom) -> Int32 -> Ptr () -> IO ()

ClipboardTextReceivedFunc

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 :: (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 -> Ptr Clipboard -> CString -> Ptr () -> IO ()

ClipboardURIReceivedFunc

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 :: (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 -> Ptr Clipboard -> Ptr CString -> Ptr () -> IO ()

ColorSelectionChangePaletteFunc

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

type ColorSelectionChangePaletteFunc = [Color] -> IO ()

Deprecated: (Since version 3.4)

dynamic_ColorSelectionChangePaletteFunc :: 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 -> Ptr Color -> Int32 -> IO ()

ColorSelectionChangePaletteWithScreenFunc

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

type ColorSelectionChangePaletteWithScreenFunc = Screen -> [Color] -> IO ()

Deprecated: (Since version 3.4)

dynamic_ColorSelectionChangePaletteWithScreenFunc :: (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 -> Ptr Screen -> Ptr Color -> Int32 -> IO ()

EntryCompletionMatchFunc

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 :: (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 -> Ptr EntryCompletion -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

FileFilterFunc

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 :: 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 -> Ptr FileFilterInfo -> Ptr () -> IO CInt

FlowBoxCreateWidgetFunc

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

type FlowBoxCreateWidgetFunc = Ptr () -> IO Widget

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

drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures

dynamic_FlowBoxCreateWidgetFunc :: MonadIO m => FunPtr C_FlowBoxCreateWidgetFunc -> Ptr () -> 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 -> Ptr () -> Ptr () -> IO (Ptr Widget)

FlowBoxFilterFunc

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 :: (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 -> Ptr FlowBoxChild -> Ptr () -> IO CInt

FlowBoxForeachFunc

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 :: (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 -> Ptr FlowBox -> Ptr FlowBoxChild -> Ptr () -> IO ()

FlowBoxSortFunc

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 :: (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 -> Ptr FlowBoxChild -> Ptr FlowBoxChild -> Ptr () -> IO Int32

FontFilterFunc

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 :: (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 -> Ptr FontFamily -> Ptr FontFace -> Ptr () -> IO CInt

IconViewForeachFunc

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 :: (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 -> Ptr IconView -> Ptr TreePath -> Ptr () -> IO ()

KeySnoopFunc

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 :: (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 -> Ptr Widget -> Ptr EventKey -> Ptr () -> IO Int32

ListBoxCreateWidgetFunc

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 :: (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 -> Ptr Object -> Ptr () -> IO (Ptr Widget)

ListBoxFilterFunc

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 :: (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 -> Ptr ListBoxRow -> Ptr () -> IO CInt

ListBoxForeachFunc

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 :: (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 -> Ptr ListBox -> Ptr ListBoxRow -> Ptr () -> IO ()

ListBoxSortFunc

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 :: (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 -> Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO Int32

ListBoxUpdateHeaderFunc

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 :: (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 -> Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO ()

MenuDetachFunc

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

type MenuDetachFunc = Widget -> Menu -> IO ()

dynamic_MenuDetachFunc :: (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 -> Ptr Widget -> Ptr Menu -> IO ()

MenuPositionFunc

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 :: (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 -> Ptr Menu -> Ptr Int32 -> Ptr Int32 -> Ptr CInt -> Ptr () -> IO ()

ModuleDisplayInitFunc

type C_ModuleDisplayInitFunc = Ptr Display -> IO ()

type ModuleDisplayInitFunc = Display -> IO ()

dynamic_ModuleDisplayInitFunc :: (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 -> Ptr Display -> IO ()

ModuleInitFunc

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

type ModuleInitFunc = Maybe [Text] -> IO ()

dynamic_ModuleInitFunc :: 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 -> Int32 -> Ptr CString -> IO ()

PageSetupDoneFunc

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 :: (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 -> Ptr PageSetup -> Ptr () -> IO ()

PrintSettingsFunc

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 :: 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 -> CString -> CString -> Ptr () -> IO ()

RcPropertyParser

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

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

dynamic_RcPropertyParser :: 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 -> Ptr GParamSpec -> Ptr String -> Ptr GValue -> IO CInt

RecentFilterFunc

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 :: 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 -> Ptr RecentFilterInfo -> Ptr () -> IO CInt

RecentSortFunc

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 :: 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 -> Ptr RecentInfo -> Ptr RecentInfo -> Ptr () -> IO Int32

StylePropertyParser

type C_StylePropertyParser = CString -> Ptr GValue -> IO CInt

type StylePropertyParser = Text -> GValue -> IO Bool

dynamic_StylePropertyParser :: MonadIO m => FunPtr C_StylePropertyParser -> Text -> GValue -> m Bool

genClosure_StylePropertyParser :: StylePropertyParser -> IO Closure

mk_StylePropertyParser :: C_StylePropertyParser -> IO (FunPtr C_StylePropertyParser)

noStylePropertyParser :: Maybe StylePropertyParser

wrap_StylePropertyParser :: Maybe (Ptr (FunPtr C_StylePropertyParser)) -> StylePropertyParser -> CString -> Ptr GValue -> IO CInt

TextBufferDeserializeFunc

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

type TextBufferDeserializeFunc = TextBuffer -> TextBuffer -> TextIter -> ByteString -> Bool -> IO Bool

type TextBufferDeserializeFunc_WithClosures = TextBuffer -> TextBuffer -> TextIter -> ByteString -> Bool -> Ptr () -> IO Bool

drop_closures_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> TextBufferDeserializeFunc_WithClosures

dynamic_TextBufferDeserializeFunc :: (MonadIO m, IsTextBuffer a, IsTextBuffer b) => FunPtr C_TextBufferDeserializeFunc -> a -> b -> TextIter -> ByteString -> Bool -> Ptr () -> m Bool

genClosure_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> IO Closure

mk_TextBufferDeserializeFunc :: C_TextBufferDeserializeFunc -> IO (FunPtr C_TextBufferDeserializeFunc)

noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc

noTextBufferDeserializeFunc_WithClosures :: Maybe TextBufferDeserializeFunc_WithClosures

wrap_TextBufferDeserializeFunc :: Maybe (Ptr (FunPtr C_TextBufferDeserializeFunc)) -> TextBufferDeserializeFunc_WithClosures -> Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr Word8 -> Word64 -> CInt -> Ptr () -> IO CInt

TextBufferSerializeFunc

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 :: (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 -> Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr TextIter -> Word64 -> Ptr () -> IO Word8

TextCharPredicate

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 :: 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 -> CInt -> Ptr () -> IO CInt

TextTagTableForeach

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

TickCallback

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 :: (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 -> Ptr Widget -> Ptr FrameClock -> Ptr () -> IO CInt

TranslateFunc

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

type TranslateFunc = Text -> IO Text

Deprecated: (Since version 3.10)

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

drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures

dynamic_TranslateFunc :: 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 -> CString -> Ptr () -> IO CString

TreeCellDataFunc

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 :: (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 -> Ptr TreeViewColumn -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

TreeDestroyCountFunc

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 :: (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 -> Ptr TreeView -> Ptr TreePath -> Int32 -> Ptr () -> IO ()

TreeIterCompareFunc

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 :: (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 -> Ptr TreeModel -> Ptr TreeIter -> Ptr TreeIter -> Ptr () -> IO Int32

TreeModelFilterVisibleFunc

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 :: (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 -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

TreeModelForeachFunc

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 :: (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 -> Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt

TreeSelectionForeachFunc

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 :: (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 -> Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()

TreeSelectionFunc

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 :: (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 -> Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt

TreeViewColumnDropFunc

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 :: (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 -> Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt

TreeViewMappingFunc

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 :: (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 -> Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()

TreeViewRowSeparatorFunc

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 :: (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 -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

TreeViewSearchEqualFunc

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 :: (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 -> Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

TreeViewSearchPositionFunc

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 :: (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 -> Ptr TreeView -> Ptr Widget -> Ptr () -> IO ()