Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria
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 :: MonadIO m => AccelGroupActivate -> m (GClosure C_AccelGroupActivate)
mk_AccelGroupActivate :: C_AccelGroupActivate -> IO (FunPtr C_AccelGroupActivate)
noAccelGroupActivate :: Maybe AccelGroupActivate
wrap_AccelGroupActivate :: Maybe (Ptr (FunPtr C_AccelGroupActivate)) -> AccelGroupActivate -> C_AccelGroupActivate
type AccelGroupFindFunc = AccelKey -> GClosure () -> IO Bool
type AccelGroupFindFunc_WithClosures = AccelKey -> GClosure () -> Ptr () -> IO Bool
type C_AccelGroupFindFunc = Ptr AccelKey -> Ptr (GClosure ()) -> Ptr () -> IO CInt
drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures
dynamic_AccelGroupFindFunc :: (HasCallStack, MonadIO m) => FunPtr C_AccelGroupFindFunc -> AccelKey -> GClosure a -> Ptr () -> m Bool
genClosure_AccelGroupFindFunc :: MonadIO m => AccelGroupFindFunc -> m (GClosure C_AccelGroupFindFunc)
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 :: MonadIO m => AccelMapForeach -> m (GClosure C_AccelMapForeach)
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 :: MonadIO m => AssistantPageFunc -> m (GClosure C_AssistantPageFunc)
mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)
noAssistantPageFunc :: Maybe AssistantPageFunc
noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures
wrap_AssistantPageFunc :: Maybe (Ptr (FunPtr C_AssistantPageFunc)) -> AssistantPageFunc_WithClosures -> C_AssistantPageFunc
type 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 :: MonadIO m => BuilderConnectFunc -> m (GClosure C_BuilderConnectFunc)
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 :: MonadIO m => CalendarDetailFunc -> m (GClosure C_CalendarDetailFunc)
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 :: MonadIO m => Callback -> m (GClosure C_Callback)
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 :: MonadIO m => CellAllocCallback -> m (GClosure C_CellAllocCallback)
mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback)
noCellAllocCallback :: Maybe CellAllocCallback
noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures
wrap_CellAllocCallback :: Maybe (Ptr (FunPtr C_CellAllocCallback)) -> CellAllocCallback_WithClosures -> C_CellAllocCallback
type C_CellCallback = Ptr CellRenderer -> Ptr () -> IO CInt
type CellCallback = CellRenderer -> IO Bool
type CellCallback_WithClosures = CellRenderer -> Ptr () -> IO Bool
drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures
dynamic_CellCallback :: (HasCallStack, MonadIO m, IsCellRenderer a) => FunPtr C_CellCallback -> a -> Ptr () -> m Bool
genClosure_CellCallback :: MonadIO m => CellCallback -> m (GClosure C_CellCallback)
mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback)
noCellCallback :: Maybe CellCallback
noCellCallback_WithClosures :: Maybe CellCallback_WithClosures
wrap_CellCallback :: Maybe (Ptr (FunPtr C_CellCallback)) -> CellCallback_WithClosures -> C_CellCallback
type C_CellLayoutDataFunc = Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()
type CellLayoutDataFunc = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> IO ()
type CellLayoutDataFunc_WithClosures = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()
drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures
dynamic_CellLayoutDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b, IsTreeModel c) => FunPtr C_CellLayoutDataFunc -> a -> b -> c -> TreeIter -> Ptr () -> m ()
genClosure_CellLayoutDataFunc :: MonadIO m => CellLayoutDataFunc -> m (GClosure C_CellLayoutDataFunc)
mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc)
noCellLayoutDataFunc :: Maybe CellLayoutDataFunc
noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures
wrap_CellLayoutDataFunc :: Maybe (Ptr (FunPtr C_CellLayoutDataFunc)) -> CellLayoutDataFunc_WithClosures -> C_CellLayoutDataFunc
type C_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 :: MonadIO m => ClipboardClearFunc -> m (GClosure C_ClipboardClearFunc)
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 :: MonadIO m => ClipboardGetFunc -> m (GClosure C_ClipboardGetFunc)
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 -> Maybe Pixbuf -> IO ()
type ClipboardImageReceivedFunc_WithClosures = Clipboard -> Maybe Pixbuf -> Ptr () -> IO ()
drop_closures_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> ClipboardImageReceivedFunc_WithClosures
dynamic_ClipboardImageReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b) => FunPtr C_ClipboardImageReceivedFunc -> a -> Maybe b -> Ptr () -> m ()
genClosure_ClipboardImageReceivedFunc :: MonadIO m => ClipboardImageReceivedFunc -> m (GClosure C_ClipboardImageReceivedFunc)
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 :: MonadIO m => ClipboardReceivedFunc -> m (GClosure C_ClipboardReceivedFunc)
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 :: MonadIO m => ClipboardRichTextReceivedFunc -> m (GClosure C_ClipboardRichTextReceivedFunc)
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 :: MonadIO m => ClipboardTargetsReceivedFunc -> m (GClosure C_ClipboardTargetsReceivedFunc)
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 :: MonadIO m => ClipboardTextReceivedFunc -> m (GClosure C_ClipboardTextReceivedFunc)
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 :: MonadIO m => ClipboardURIReceivedFunc -> m (GClosure C_ClipboardURIReceivedFunc)
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 :: MonadIO m => ColorSelectionChangePaletteFunc -> m (GClosure C_ColorSelectionChangePaletteFunc)
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 :: MonadIO m => ColorSelectionChangePaletteWithScreenFunc -> m (GClosure C_ColorSelectionChangePaletteWithScreenFunc)
mk_ColorSelectionChangePaletteWithScreenFunc :: C_ColorSelectionChangePaletteWithScreenFunc -> IO (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)
noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc
wrap_ColorSelectionChangePaletteWithScreenFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)) -> ColorSelectionChangePaletteWithScreenFunc -> C_ColorSelectionChangePaletteWithScreenFunc
type C_ContainerClassAddFieldCallback = Ptr Container -> Ptr Widget -> IO ()
type ContainerClassAddFieldCallback = Container -> Widget -> IO ()
dynamic_ContainerClassAddFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassAddFieldCallback -> a -> b -> m ()
genClosure_ContainerClassAddFieldCallback :: MonadIO m => ContainerClassAddFieldCallback -> m (GClosure C_ContainerClassAddFieldCallback)
mk_ContainerClassAddFieldCallback :: C_ContainerClassAddFieldCallback -> IO (FunPtr C_ContainerClassAddFieldCallback)
noContainerClassAddFieldCallback :: Maybe ContainerClassAddFieldCallback
wrap_ContainerClassAddFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassAddFieldCallback)) -> ContainerClassAddFieldCallback -> C_ContainerClassAddFieldCallback
type C_ContainerClassCheckResizeFieldCallback = Ptr Container -> IO ()
type ContainerClassCheckResizeFieldCallback = Container -> IO ()
dynamic_ContainerClassCheckResizeFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassCheckResizeFieldCallback -> a -> m ()
genClosure_ContainerClassCheckResizeFieldCallback :: MonadIO m => ContainerClassCheckResizeFieldCallback -> m (GClosure C_ContainerClassCheckResizeFieldCallback)
mk_ContainerClassCheckResizeFieldCallback :: C_ContainerClassCheckResizeFieldCallback -> IO (FunPtr C_ContainerClassCheckResizeFieldCallback)
noContainerClassCheckResizeFieldCallback :: Maybe ContainerClassCheckResizeFieldCallback
wrap_ContainerClassCheckResizeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)) -> ContainerClassCheckResizeFieldCallback -> C_ContainerClassCheckResizeFieldCallback
type C_ContainerClassChildTypeFieldCallback = Ptr Container -> IO CGType
type ContainerClassChildTypeFieldCallback = Container -> IO GType
dynamic_ContainerClassChildTypeFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassChildTypeFieldCallback -> a -> m GType
genClosure_ContainerClassChildTypeFieldCallback :: MonadIO m => ContainerClassChildTypeFieldCallback -> m (GClosure C_ContainerClassChildTypeFieldCallback)
mk_ContainerClassChildTypeFieldCallback :: C_ContainerClassChildTypeFieldCallback -> IO (FunPtr C_ContainerClassChildTypeFieldCallback)
noContainerClassChildTypeFieldCallback :: Maybe ContainerClassChildTypeFieldCallback
wrap_ContainerClassChildTypeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)) -> ContainerClassChildTypeFieldCallback -> C_ContainerClassChildTypeFieldCallback
type C_ContainerClassCompositeNameFieldCallback = Ptr Container -> Ptr Widget -> IO CString
type ContainerClassCompositeNameFieldCallback = Container -> Widget -> IO Text
dynamic_ContainerClassCompositeNameFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassCompositeNameFieldCallback -> a -> b -> m Text
genClosure_ContainerClassCompositeNameFieldCallback :: MonadIO m => ContainerClassCompositeNameFieldCallback -> m (GClosure C_ContainerClassCompositeNameFieldCallback)
mk_ContainerClassCompositeNameFieldCallback :: C_ContainerClassCompositeNameFieldCallback -> IO (FunPtr C_ContainerClassCompositeNameFieldCallback)
noContainerClassCompositeNameFieldCallback :: Maybe ContainerClassCompositeNameFieldCallback
wrap_ContainerClassCompositeNameFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)) -> ContainerClassCompositeNameFieldCallback -> C_ContainerClassCompositeNameFieldCallback
type C_ContainerClassForallFieldCallback = Ptr Container -> CInt -> FunPtr C_Callback -> Ptr () -> IO ()
type ContainerClassForallFieldCallback = Container -> Bool -> Callback_WithClosures -> IO ()
type ContainerClassForallFieldCallback_WithClosures = Container -> Bool -> Callback_WithClosures -> Ptr () -> IO ()
drop_closures_ContainerClassForallFieldCallback :: ContainerClassForallFieldCallback -> ContainerClassForallFieldCallback_WithClosures
dynamic_ContainerClassForallFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassForallFieldCallback -> a -> Bool -> Callback_WithClosures -> Ptr () -> m ()
genClosure_ContainerClassForallFieldCallback :: MonadIO m => ContainerClassForallFieldCallback -> m (GClosure C_ContainerClassForallFieldCallback)
mk_ContainerClassForallFieldCallback :: C_ContainerClassForallFieldCallback -> IO (FunPtr C_ContainerClassForallFieldCallback)
noContainerClassForallFieldCallback :: Maybe ContainerClassForallFieldCallback
noContainerClassForallFieldCallback_WithClosures :: Maybe ContainerClassForallFieldCallback_WithClosures
wrap_ContainerClassForallFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassForallFieldCallback)) -> ContainerClassForallFieldCallback_WithClosures -> C_ContainerClassForallFieldCallback
type C_ContainerClassGetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
type ContainerClassGetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO ()
dynamic_ContainerClassGetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassGetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()
genClosure_ContainerClassGetChildPropertyFieldCallback :: MonadIO m => ContainerClassGetChildPropertyFieldCallback -> m (GClosure C_ContainerClassGetChildPropertyFieldCallback)
mk_ContainerClassGetChildPropertyFieldCallback :: C_ContainerClassGetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassGetChildPropertyFieldCallback)
noContainerClassGetChildPropertyFieldCallback :: Maybe ContainerClassGetChildPropertyFieldCallback
wrap_ContainerClassGetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetChildPropertyFieldCallback)) -> ContainerClassGetChildPropertyFieldCallback -> C_ContainerClassGetChildPropertyFieldCallback
type C_ContainerClassGetPathForChildFieldCallback = Ptr Container -> Ptr Widget -> IO (Ptr WidgetPath)
type ContainerClassGetPathForChildFieldCallback = Container -> Widget -> IO WidgetPath
dynamic_ContainerClassGetPathForChildFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassGetPathForChildFieldCallback -> a -> b -> m WidgetPath
genClosure_ContainerClassGetPathForChildFieldCallback :: MonadIO m => ContainerClassGetPathForChildFieldCallback -> m (GClosure C_ContainerClassGetPathForChildFieldCallback)
mk_ContainerClassGetPathForChildFieldCallback :: C_ContainerClassGetPathForChildFieldCallback -> IO (FunPtr C_ContainerClassGetPathForChildFieldCallback)
noContainerClassGetPathForChildFieldCallback :: Maybe ContainerClassGetPathForChildFieldCallback
wrap_ContainerClassGetPathForChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)) -> ContainerClassGetPathForChildFieldCallback -> C_ContainerClassGetPathForChildFieldCallback
type C_ContainerClassRemoveFieldCallback = Ptr Container -> Ptr Widget -> IO ()
type ContainerClassRemoveFieldCallback = Container -> Widget -> IO ()
dynamic_ContainerClassRemoveFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassRemoveFieldCallback -> a -> b -> m ()
genClosure_ContainerClassRemoveFieldCallback :: MonadIO m => ContainerClassRemoveFieldCallback -> m (GClosure C_ContainerClassRemoveFieldCallback)
mk_ContainerClassRemoveFieldCallback :: C_ContainerClassRemoveFieldCallback -> IO (FunPtr C_ContainerClassRemoveFieldCallback)
noContainerClassRemoveFieldCallback :: Maybe ContainerClassRemoveFieldCallback
wrap_ContainerClassRemoveFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassRemoveFieldCallback)) -> ContainerClassRemoveFieldCallback -> C_ContainerClassRemoveFieldCallback
type C_ContainerClassSetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
type ContainerClassSetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO ()
dynamic_ContainerClassSetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassSetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()
genClosure_ContainerClassSetChildPropertyFieldCallback :: MonadIO m => ContainerClassSetChildPropertyFieldCallback -> m (GClosure C_ContainerClassSetChildPropertyFieldCallback)
mk_ContainerClassSetChildPropertyFieldCallback :: C_ContainerClassSetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)
noContainerClassSetChildPropertyFieldCallback :: Maybe ContainerClassSetChildPropertyFieldCallback
wrap_ContainerClassSetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)) -> ContainerClassSetChildPropertyFieldCallback -> C_ContainerClassSetChildPropertyFieldCallback
type C_ContainerClassSetFocusChildFieldCallback = Ptr Container -> Ptr Widget -> IO ()
type ContainerClassSetFocusChildFieldCallback = Container -> Maybe Widget -> IO ()
dynamic_ContainerClassSetFocusChildFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassSetFocusChildFieldCallback -> a -> Maybe b -> m ()
genClosure_ContainerClassSetFocusChildFieldCallback :: MonadIO m => ContainerClassSetFocusChildFieldCallback -> m (GClosure C_ContainerClassSetFocusChildFieldCallback)
mk_ContainerClassSetFocusChildFieldCallback :: C_ContainerClassSetFocusChildFieldCallback -> IO (FunPtr C_ContainerClassSetFocusChildFieldCallback)
noContainerClassSetFocusChildFieldCallback :: Maybe ContainerClassSetFocusChildFieldCallback
wrap_ContainerClassSetFocusChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetFocusChildFieldCallback)) -> ContainerClassSetFocusChildFieldCallback -> C_ContainerClassSetFocusChildFieldCallback
type C_EntryCompletionMatchFunc = Ptr EntryCompletion -> CString -> Ptr TreeIter -> Ptr () -> IO CInt
type EntryCompletionMatchFunc = EntryCompletion -> Text -> TreeIter -> IO Bool
type EntryCompletionMatchFunc_WithClosures = EntryCompletion -> Text -> TreeIter -> Ptr () -> IO Bool
drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures
dynamic_EntryCompletionMatchFunc :: (HasCallStack, MonadIO m, IsEntryCompletion a) => FunPtr C_EntryCompletionMatchFunc -> a -> Text -> TreeIter -> Ptr () -> m Bool
genClosure_EntryCompletionMatchFunc :: MonadIO m => EntryCompletionMatchFunc -> m (GClosure C_EntryCompletionMatchFunc)
mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc)
noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc
noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures
wrap_EntryCompletionMatchFunc :: Maybe (Ptr (FunPtr C_EntryCompletionMatchFunc)) -> EntryCompletionMatchFunc_WithClosures -> C_EntryCompletionMatchFunc
type C_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 :: MonadIO m => FileFilterFunc -> m (GClosure C_FileFilterFunc)
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 :: MonadIO m => FlowBoxCreateWidgetFunc -> m (GClosure C_FlowBoxCreateWidgetFunc)
mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc)
noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc
noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures
wrap_FlowBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_FlowBoxCreateWidgetFunc)) -> FlowBoxCreateWidgetFunc_WithClosures -> C_FlowBoxCreateWidgetFunc
type C_FlowBoxFilterFunc = Ptr FlowBoxChild -> Ptr () -> IO CInt
type FlowBoxFilterFunc = FlowBoxChild -> IO Bool
type FlowBoxFilterFunc_WithClosures = FlowBoxChild -> Ptr () -> IO Bool
drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures
dynamic_FlowBoxFilterFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => FunPtr C_FlowBoxFilterFunc -> a -> Ptr () -> m Bool
genClosure_FlowBoxFilterFunc :: MonadIO m => FlowBoxFilterFunc -> m (GClosure C_FlowBoxFilterFunc)
mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc)
noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc
noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures
wrap_FlowBoxFilterFunc :: Maybe (Ptr (FunPtr C_FlowBoxFilterFunc)) -> FlowBoxFilterFunc_WithClosures -> C_FlowBoxFilterFunc
type C_FlowBoxForeachFunc = Ptr FlowBox -> Ptr FlowBoxChild -> Ptr () -> IO ()
type FlowBoxForeachFunc = FlowBox -> FlowBoxChild -> IO ()
type FlowBoxForeachFunc_WithClosures = FlowBox -> FlowBoxChild -> Ptr () -> IO ()
drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures
dynamic_FlowBoxForeachFunc :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => FunPtr C_FlowBoxForeachFunc -> a -> b -> Ptr () -> m ()
genClosure_FlowBoxForeachFunc :: MonadIO m => FlowBoxForeachFunc -> m (GClosure C_FlowBoxForeachFunc)
mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc)
noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc
noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures
wrap_FlowBoxForeachFunc :: Maybe (Ptr (FunPtr C_FlowBoxForeachFunc)) -> FlowBoxForeachFunc_WithClosures -> C_FlowBoxForeachFunc
type C_FlowBoxSortFunc = Ptr FlowBoxChild -> Ptr FlowBoxChild -> Ptr () -> IO Int32
type FlowBoxSortFunc = FlowBoxChild -> FlowBoxChild -> IO Int32
type FlowBoxSortFunc_WithClosures = FlowBoxChild -> FlowBoxChild -> Ptr () -> IO Int32
drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures
dynamic_FlowBoxSortFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a, IsFlowBoxChild b) => FunPtr C_FlowBoxSortFunc -> a -> b -> Ptr () -> m Int32
genClosure_FlowBoxSortFunc :: MonadIO m => FlowBoxSortFunc -> m (GClosure C_FlowBoxSortFunc)
mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc)
noFlowBoxSortFunc :: Maybe FlowBoxSortFunc
noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures
wrap_FlowBoxSortFunc :: Maybe (Ptr (FunPtr C_FlowBoxSortFunc)) -> FlowBoxSortFunc_WithClosures -> C_FlowBoxSortFunc
type C_FontFilterFunc = Ptr FontFamily -> Ptr FontFace -> Ptr () -> IO CInt
type FontFilterFunc = FontFamily -> FontFace -> IO Bool
type FontFilterFunc_WithClosures = FontFamily -> FontFace -> Ptr () -> IO Bool
drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures
dynamic_FontFilterFunc :: (HasCallStack, MonadIO m, IsFontFamily a, IsFontFace b) => FunPtr C_FontFilterFunc -> a -> b -> Ptr () -> m Bool
genClosure_FontFilterFunc :: MonadIO m => FontFilterFunc -> m (GClosure C_FontFilterFunc)
mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc)
noFontFilterFunc :: Maybe FontFilterFunc
noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures
wrap_FontFilterFunc :: Maybe (Ptr (FunPtr C_FontFilterFunc)) -> FontFilterFunc_WithClosures -> C_FontFilterFunc
type C_IconViewForeachFunc = Ptr IconView -> Ptr TreePath -> Ptr () -> IO ()
type IconViewForeachFunc = IconView -> TreePath -> IO ()
type IconViewForeachFunc_WithClosures = IconView -> TreePath -> Ptr () -> IO ()
drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures
dynamic_IconViewForeachFunc :: (HasCallStack, MonadIO m, IsIconView a) => FunPtr C_IconViewForeachFunc -> a -> TreePath -> Ptr () -> m ()
genClosure_IconViewForeachFunc :: MonadIO m => IconViewForeachFunc -> m (GClosure C_IconViewForeachFunc)
mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc)
noIconViewForeachFunc :: Maybe IconViewForeachFunc
noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures
wrap_IconViewForeachFunc :: Maybe (Ptr (FunPtr C_IconViewForeachFunc)) -> IconViewForeachFunc_WithClosures -> C_IconViewForeachFunc
type C_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 :: MonadIO m => KeySnoopFunc -> m (GClosure C_KeySnoopFunc)
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 :: MonadIO m => ListBoxCreateWidgetFunc -> m (GClosure C_ListBoxCreateWidgetFunc)
mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc)
noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc
noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures
wrap_ListBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_ListBoxCreateWidgetFunc)) -> ListBoxCreateWidgetFunc_WithClosures -> C_ListBoxCreateWidgetFunc
type C_ListBoxFilterFunc = Ptr ListBoxRow -> Ptr () -> IO CInt
type ListBoxFilterFunc = ListBoxRow -> IO Bool
type ListBoxFilterFunc_WithClosures = ListBoxRow -> Ptr () -> IO Bool
drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures
dynamic_ListBoxFilterFunc :: (HasCallStack, MonadIO m, IsListBoxRow a) => FunPtr C_ListBoxFilterFunc -> a -> Ptr () -> m Bool
genClosure_ListBoxFilterFunc :: MonadIO m => ListBoxFilterFunc -> m (GClosure C_ListBoxFilterFunc)
mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc)
noListBoxFilterFunc :: Maybe ListBoxFilterFunc
noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures
wrap_ListBoxFilterFunc :: Maybe (Ptr (FunPtr C_ListBoxFilterFunc)) -> ListBoxFilterFunc_WithClosures -> C_ListBoxFilterFunc
type C_ListBoxForeachFunc = Ptr ListBox -> Ptr ListBoxRow -> Ptr () -> IO ()
type ListBoxForeachFunc = ListBox -> ListBoxRow -> IO ()
type ListBoxForeachFunc_WithClosures = ListBox -> ListBoxRow -> Ptr () -> IO ()
drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures
dynamic_ListBoxForeachFunc :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => FunPtr C_ListBoxForeachFunc -> a -> b -> Ptr () -> m ()
genClosure_ListBoxForeachFunc :: MonadIO m => ListBoxForeachFunc -> m (GClosure C_ListBoxForeachFunc)
mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc)
noListBoxForeachFunc :: Maybe ListBoxForeachFunc
noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures
wrap_ListBoxForeachFunc :: Maybe (Ptr (FunPtr C_ListBoxForeachFunc)) -> ListBoxForeachFunc_WithClosures -> C_ListBoxForeachFunc
type C_ListBoxSortFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO Int32
type ListBoxSortFunc = ListBoxRow -> ListBoxRow -> IO Int32
type ListBoxSortFunc_WithClosures = ListBoxRow -> ListBoxRow -> Ptr () -> IO Int32
drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures
dynamic_ListBoxSortFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxSortFunc -> a -> b -> Ptr () -> m Int32
genClosure_ListBoxSortFunc :: MonadIO m => ListBoxSortFunc -> m (GClosure C_ListBoxSortFunc)
mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc)
noListBoxSortFunc :: Maybe ListBoxSortFunc
noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures
wrap_ListBoxSortFunc :: Maybe (Ptr (FunPtr C_ListBoxSortFunc)) -> ListBoxSortFunc_WithClosures -> C_ListBoxSortFunc
type C_ListBoxUpdateHeaderFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO ()
type ListBoxUpdateHeaderFunc = ListBoxRow -> Maybe ListBoxRow -> IO ()
type ListBoxUpdateHeaderFunc_WithClosures = ListBoxRow -> Maybe ListBoxRow -> Ptr () -> IO ()
drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures
dynamic_ListBoxUpdateHeaderFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxUpdateHeaderFunc -> a -> Maybe b -> Ptr () -> m ()
genClosure_ListBoxUpdateHeaderFunc :: MonadIO m => ListBoxUpdateHeaderFunc -> m (GClosure C_ListBoxUpdateHeaderFunc)
mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc)
noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc
noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures
wrap_ListBoxUpdateHeaderFunc :: Maybe (Ptr (FunPtr C_ListBoxUpdateHeaderFunc)) -> ListBoxUpdateHeaderFunc_WithClosures -> C_ListBoxUpdateHeaderFunc
type C_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 :: MonadIO m => MenuDetachFunc -> m (GClosure C_MenuDetachFunc)
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 :: MonadIO m => MenuPositionFunc -> m (GClosure C_MenuPositionFunc)
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 :: MonadIO m => ModuleDisplayInitFunc -> m (GClosure C_ModuleDisplayInitFunc)
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 :: MonadIO m => ModuleInitFunc -> m (GClosure C_ModuleInitFunc)
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 :: MonadIO m => PageSetupDoneFunc -> m (GClosure C_PageSetupDoneFunc)
mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc)
noPageSetupDoneFunc :: Maybe PageSetupDoneFunc
noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures
wrap_PageSetupDoneFunc :: Maybe (Ptr (FunPtr C_PageSetupDoneFunc)) -> PageSetupDoneFunc_WithClosures -> C_PageSetupDoneFunc
type C_PrintSettingsFunc = CString -> CString -> Ptr () -> IO ()
type PrintSettingsFunc = Text -> Text -> IO ()
type PrintSettingsFunc_WithClosures = Text -> Text -> Ptr () -> IO ()
drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures
dynamic_PrintSettingsFunc :: (HasCallStack, MonadIO m) => FunPtr C_PrintSettingsFunc -> Text -> Text -> Ptr () -> m ()
genClosure_PrintSettingsFunc :: MonadIO m => PrintSettingsFunc -> m (GClosure C_PrintSettingsFunc)
mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc)
noPrintSettingsFunc :: Maybe PrintSettingsFunc
noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures
wrap_PrintSettingsFunc :: Maybe (Ptr (FunPtr C_PrintSettingsFunc)) -> PrintSettingsFunc_WithClosures -> C_PrintSettingsFunc
type C_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 :: MonadIO m => RcPropertyParser -> m (GClosure C_RcPropertyParser)
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 :: MonadIO m => RecentFilterFunc -> m (GClosure C_RecentFilterFunc)
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 :: MonadIO m => RecentSortFunc -> m (GClosure C_RecentSortFunc)
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 :: MonadIO m => TextBufferSerializeFunc -> m (GClosure C_TextBufferSerializeFunc)
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 :: MonadIO m => TextCharPredicate -> m (GClosure C_TextCharPredicate)
mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate)
noTextCharPredicate :: Maybe TextCharPredicate
noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures
wrap_TextCharPredicate :: Maybe (Ptr (FunPtr C_TextCharPredicate)) -> TextCharPredicate_WithClosures -> C_TextCharPredicate
type C_TextTagTableForeach = Ptr TextTag -> Ptr () -> IO ()
type TextTagTableForeach = TextTag -> IO ()
type TextTagTableForeach_WithClosures = TextTag -> Ptr () -> IO ()
drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures
dynamic_TextTagTableForeach :: (HasCallStack, MonadIO m, IsTextTag a) => FunPtr C_TextTagTableForeach -> a -> Ptr () -> m ()
genClosure_TextTagTableForeach :: MonadIO m => TextTagTableForeach -> m (GClosure C_TextTagTableForeach)
mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)
noTextTagTableForeach :: Maybe TextTagTableForeach
noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures
wrap_TextTagTableForeach :: Maybe (Ptr (FunPtr C_TextTagTableForeach)) -> TextTagTableForeach_WithClosures -> C_TextTagTableForeach
type C_TickCallback = Ptr Widget -> Ptr FrameClock -> Ptr () -> IO CInt
type TickCallback = Widget -> FrameClock -> IO Bool
type TickCallback_WithClosures = Widget -> FrameClock -> Ptr () -> IO Bool
drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures
dynamic_TickCallback :: (HasCallStack, MonadIO m, IsWidget a, IsFrameClock b) => FunPtr C_TickCallback -> a -> b -> Ptr () -> m Bool
genClosure_TickCallback :: MonadIO m => TickCallback -> m (GClosure C_TickCallback)
mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback)
noTickCallback :: Maybe TickCallback
noTickCallback_WithClosures :: Maybe TickCallback_WithClosures
wrap_TickCallback :: Maybe (Ptr (FunPtr C_TickCallback)) -> TickCallback_WithClosures -> C_TickCallback
type C_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 :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc)
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 :: MonadIO m => TreeCellDataFunc -> m (GClosure C_TreeCellDataFunc)
mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)
noTreeCellDataFunc :: Maybe TreeCellDataFunc
noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures
wrap_TreeCellDataFunc :: Maybe (Ptr (FunPtr C_TreeCellDataFunc)) -> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc
type C_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 :: MonadIO m => TreeDestroyCountFunc -> m (GClosure C_TreeDestroyCountFunc)
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 :: MonadIO m => TreeIterCompareFunc -> m (GClosure C_TreeIterCompareFunc)
mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)
noTreeIterCompareFunc :: Maybe TreeIterCompareFunc
noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures
wrap_TreeIterCompareFunc :: Maybe (Ptr (FunPtr C_TreeIterCompareFunc)) -> TreeIterCompareFunc_WithClosures -> C_TreeIterCompareFunc
type C_TreeModelFilterVisibleFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeModelFilterVisibleFunc = TreeModel -> TreeIter -> IO Bool
type TreeModelFilterVisibleFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures
dynamic_TreeModelFilterVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterVisibleFunc -> a -> TreeIter -> Ptr () -> m Bool
genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc)
mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)
noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc
noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures
wrap_TreeModelFilterVisibleFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc)) -> TreeModelFilterVisibleFunc_WithClosures -> C_TreeModelFilterVisibleFunc
type C_TreeModelForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeModelForeachFunc = TreeModel -> TreePath -> TreeIter -> IO Bool
type TreeModelForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures
dynamic_TreeModelForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m Bool
genClosure_TreeModelForeachFunc :: MonadIO m => TreeModelForeachFunc -> m (GClosure C_TreeModelForeachFunc)
mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)
noTreeModelForeachFunc :: Maybe TreeModelForeachFunc
noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures
wrap_TreeModelForeachFunc :: Maybe (Ptr (FunPtr C_TreeModelForeachFunc)) -> TreeModelForeachFunc_WithClosures -> C_TreeModelForeachFunc
type C_TreeSelectionForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()
type TreeSelectionForeachFunc = TreeModel -> TreePath -> TreeIter -> IO ()
type TreeSelectionForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO ()
drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures
dynamic_TreeSelectionForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeSelectionForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m ()
genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc)
mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)
noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc
noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures
wrap_TreeSelectionForeachFunc :: Maybe (Ptr (FunPtr C_TreeSelectionForeachFunc)) -> TreeSelectionForeachFunc_WithClosures -> C_TreeSelectionForeachFunc
type C_TreeSelectionFunc = Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt
type TreeSelectionFunc = TreeSelection -> TreeModel -> TreePath -> Bool -> IO Bool
type TreeSelectionFunc_WithClosures = TreeSelection -> TreeModel -> TreePath -> Bool -> Ptr () -> IO Bool
drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures
dynamic_TreeSelectionFunc :: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b) => FunPtr C_TreeSelectionFunc -> a -> b -> TreePath -> Bool -> Ptr () -> m Bool
genClosure_TreeSelectionFunc :: MonadIO m => TreeSelectionFunc -> m (GClosure C_TreeSelectionFunc)
mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)
noTreeSelectionFunc :: Maybe TreeSelectionFunc
noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures
wrap_TreeSelectionFunc :: Maybe (Ptr (FunPtr C_TreeSelectionFunc)) -> TreeSelectionFunc_WithClosures -> C_TreeSelectionFunc
type C_TreeViewColumnDropFunc = Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt
type TreeViewColumnDropFunc = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> IO Bool
type TreeViewColumnDropFunc_WithClosures = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> Ptr () -> IO Bool
drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures
dynamic_TreeViewColumnDropFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d) => FunPtr C_TreeViewColumnDropFunc -> a -> b -> c -> d -> Ptr () -> m Bool
genClosure_TreeViewColumnDropFunc :: MonadIO m => TreeViewColumnDropFunc -> m (GClosure C_TreeViewColumnDropFunc)
mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)
noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc
noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures
wrap_TreeViewColumnDropFunc :: Maybe (Ptr (FunPtr C_TreeViewColumnDropFunc)) -> TreeViewColumnDropFunc_WithClosures -> C_TreeViewColumnDropFunc
type C_TreeViewMappingFunc = Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()
type TreeViewMappingFunc = TreeView -> TreePath -> IO ()
type TreeViewMappingFunc_WithClosures = TreeView -> TreePath -> Ptr () -> IO ()
drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures
dynamic_TreeViewMappingFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeViewMappingFunc -> a -> TreePath -> Ptr () -> m ()
genClosure_TreeViewMappingFunc :: MonadIO m => TreeViewMappingFunc -> m (GClosure C_TreeViewMappingFunc)
mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)
noTreeViewMappingFunc :: Maybe TreeViewMappingFunc
noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures
wrap_TreeViewMappingFunc :: Maybe (Ptr (FunPtr C_TreeViewMappingFunc)) -> TreeViewMappingFunc_WithClosures -> C_TreeViewMappingFunc
type C_TreeViewRowSeparatorFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeViewRowSeparatorFunc = TreeModel -> TreeIter -> IO Bool
type TreeViewRowSeparatorFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures
dynamic_TreeViewRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewRowSeparatorFunc -> a -> TreeIter -> Ptr () -> m Bool
genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc)
mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)
noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc
noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures
wrap_TreeViewRowSeparatorFunc :: Maybe (Ptr (FunPtr C_TreeViewRowSeparatorFunc)) -> TreeViewRowSeparatorFunc_WithClosures -> C_TreeViewRowSeparatorFunc
type C_TreeViewSearchEqualFunc = Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt
type TreeViewSearchEqualFunc = TreeModel -> Int32 -> Text -> TreeIter -> IO Bool
type TreeViewSearchEqualFunc_WithClosures = TreeModel -> Int32 -> Text -> TreeIter -> Ptr () -> IO Bool
drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures
dynamic_TreeViewSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewSearchEqualFunc -> a -> Int32 -> Text -> TreeIter -> Ptr () -> m Bool
genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc)
mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)
noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc
noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures
wrap_TreeViewSearchEqualFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchEqualFunc)) -> TreeViewSearchEqualFunc_WithClosures -> C_TreeViewSearchEqualFunc
type C_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 :: MonadIO m => TreeViewSearchPositionFunc -> m (GClosure C_TreeViewSearchPositionFunc)
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
type C_WidgetClassAdjustBaselineAllocationFieldCallback = Ptr Widget -> Int32 -> IO ()
type WidgetClassAdjustBaselineAllocationFieldCallback = Widget -> Int32 -> IO ()
dynamic_WidgetClassAdjustBaselineAllocationFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback -> a -> Int32 -> m ()
genClosure_WidgetClassAdjustBaselineAllocationFieldCallback :: MonadIO m => WidgetClassAdjustBaselineAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineAllocationFieldCallback)
mk_WidgetClassAdjustBaselineAllocationFieldCallback :: C_WidgetClassAdjustBaselineAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)
noWidgetClassAdjustBaselineAllocationFieldCallback :: Maybe WidgetClassAdjustBaselineAllocationFieldCallback
wrap_WidgetClassAdjustBaselineAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)) -> WidgetClassAdjustBaselineAllocationFieldCallback -> C_WidgetClassAdjustBaselineAllocationFieldCallback
type C_WidgetClassAdjustBaselineRequestFieldCallback = Ptr Widget -> Int32 -> Int32 -> IO ()
type WidgetClassAdjustBaselineRequestFieldCallback = Widget -> Int32 -> Int32 -> IO ()
dynamic_WidgetClassAdjustBaselineRequestFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> a -> Int32 -> Int32 -> m ()
genClosure_WidgetClassAdjustBaselineRequestFieldCallback :: MonadIO m => WidgetClassAdjustBaselineRequestFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineRequestFieldCallback)
mk_WidgetClassAdjustBaselineRequestFieldCallback :: C_WidgetClassAdjustBaselineRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)
noWidgetClassAdjustBaselineRequestFieldCallback :: Maybe WidgetClassAdjustBaselineRequestFieldCallback
wrap_WidgetClassAdjustBaselineRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)) -> WidgetClassAdjustBaselineRequestFieldCallback -> C_WidgetClassAdjustBaselineRequestFieldCallback
type C_WidgetClassAdjustSizeAllocationFieldCallback = Ptr Widget -> CUInt -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()
type WidgetClassAdjustSizeAllocationFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()
dynamic_WidgetClassAdjustSizeAllocationFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> a -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> m ()
genClosure_WidgetClassAdjustSizeAllocationFieldCallback :: MonadIO m => WidgetClassAdjustSizeAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustSizeAllocationFieldCallback)
mk_WidgetClassAdjustSizeAllocationFieldCallback :: C_WidgetClassAdjustSizeAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)
noWidgetClassAdjustSizeAllocationFieldCallback :: Maybe WidgetClassAdjustSizeAllocationFieldCallback
wrap_WidgetClassAdjustSizeAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)) -> WidgetClassAdjustSizeAllocationFieldCallback -> C_WidgetClassAdjustSizeAllocationFieldCallback
type C_WidgetClassAdjustSizeRequestFieldCallback = Ptr Widget -> CUInt -> Int32 -> Int32 -> IO ()
type WidgetClassAdjustSizeRequestFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> IO ()
dynamic_WidgetClassAdjustSizeRequestFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> a -> Orientation -> Int32 -> Int32 -> m ()
genClosure_WidgetClassAdjustSizeRequestFieldCallback :: MonadIO m => WidgetClassAdjustSizeRequestFieldCallback -> m (GClosure C_WidgetClassAdjustSizeRequestFieldCallback)
mk_WidgetClassAdjustSizeRequestFieldCallback :: C_WidgetClassAdjustSizeRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)
noWidgetClassAdjustSizeRequestFieldCallback :: Maybe WidgetClassAdjustSizeRequestFieldCallback
wrap_WidgetClassAdjustSizeRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)) -> WidgetClassAdjustSizeRequestFieldCallback -> C_WidgetClassAdjustSizeRequestFieldCallback
type C_WidgetClassButtonPressEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt
type WidgetClassButtonPressEventFieldCallback = Widget -> EventButton -> IO Bool
dynamic_WidgetClassButtonPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonPressEventFieldCallback -> a -> EventButton -> m Bool
genClosure_WidgetClassButtonPressEventFieldCallback :: MonadIO m => WidgetClassButtonPressEventFieldCallback -> m (GClosure C_WidgetClassButtonPressEventFieldCallback)
mk_WidgetClassButtonPressEventFieldCallback :: C_WidgetClassButtonPressEventFieldCallback -> IO (FunPtr C_WidgetClassButtonPressEventFieldCallback)
noWidgetClassButtonPressEventFieldCallback :: Maybe WidgetClassButtonPressEventFieldCallback
wrap_WidgetClassButtonPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)) -> WidgetClassButtonPressEventFieldCallback -> C_WidgetClassButtonPressEventFieldCallback
type C_WidgetClassButtonReleaseEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt
type WidgetClassButtonReleaseEventFieldCallback = Widget -> EventButton -> IO Bool
dynamic_WidgetClassButtonReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonReleaseEventFieldCallback -> a -> EventButton -> m Bool
genClosure_WidgetClassButtonReleaseEventFieldCallback :: MonadIO m => WidgetClassButtonReleaseEventFieldCallback -> m (GClosure C_WidgetClassButtonReleaseEventFieldCallback)
mk_WidgetClassButtonReleaseEventFieldCallback :: C_WidgetClassButtonReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)
noWidgetClassButtonReleaseEventFieldCallback :: Maybe WidgetClassButtonReleaseEventFieldCallback
wrap_WidgetClassButtonReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)) -> WidgetClassButtonReleaseEventFieldCallback -> C_WidgetClassButtonReleaseEventFieldCallback
type C_WidgetClassCanActivateAccelFieldCallback = Ptr Widget -> Word32 -> IO CInt
type WidgetClassCanActivateAccelFieldCallback = Widget -> Word32 -> IO Bool
dynamic_WidgetClassCanActivateAccelFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCanActivateAccelFieldCallback -> a -> Word32 -> m Bool
genClosure_WidgetClassCanActivateAccelFieldCallback :: MonadIO m => WidgetClassCanActivateAccelFieldCallback -> m (GClosure C_WidgetClassCanActivateAccelFieldCallback)
mk_WidgetClassCanActivateAccelFieldCallback :: C_WidgetClassCanActivateAccelFieldCallback -> IO (FunPtr C_WidgetClassCanActivateAccelFieldCallback)
noWidgetClassCanActivateAccelFieldCallback :: Maybe WidgetClassCanActivateAccelFieldCallback
wrap_WidgetClassCanActivateAccelFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)) -> WidgetClassCanActivateAccelFieldCallback -> C_WidgetClassCanActivateAccelFieldCallback
type C_WidgetClassChildNotifyFieldCallback = Ptr Widget -> Ptr GParamSpec -> IO ()
type WidgetClassChildNotifyFieldCallback = Widget -> GParamSpec -> IO ()
dynamic_WidgetClassChildNotifyFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassChildNotifyFieldCallback -> a -> GParamSpec -> m ()
genClosure_WidgetClassChildNotifyFieldCallback :: MonadIO m => WidgetClassChildNotifyFieldCallback -> m (GClosure C_WidgetClassChildNotifyFieldCallback)
mk_WidgetClassChildNotifyFieldCallback :: C_WidgetClassChildNotifyFieldCallback -> IO (FunPtr C_WidgetClassChildNotifyFieldCallback)
noWidgetClassChildNotifyFieldCallback :: Maybe WidgetClassChildNotifyFieldCallback
wrap_WidgetClassChildNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassChildNotifyFieldCallback)) -> WidgetClassChildNotifyFieldCallback -> C_WidgetClassChildNotifyFieldCallback
type C_WidgetClassCompositedChangedFieldCallback = Ptr Widget -> IO ()
type WidgetClassCompositedChangedFieldCallback = Widget -> IO ()
dynamic_WidgetClassCompositedChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCompositedChangedFieldCallback -> a -> m ()
genClosure_WidgetClassCompositedChangedFieldCallback :: MonadIO m => WidgetClassCompositedChangedFieldCallback -> m (GClosure C_WidgetClassCompositedChangedFieldCallback)
mk_WidgetClassCompositedChangedFieldCallback :: C_WidgetClassCompositedChangedFieldCallback -> IO (FunPtr C_WidgetClassCompositedChangedFieldCallback)
noWidgetClassCompositedChangedFieldCallback :: Maybe WidgetClassCompositedChangedFieldCallback
wrap_WidgetClassCompositedChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCompositedChangedFieldCallback)) -> WidgetClassCompositedChangedFieldCallback -> C_WidgetClassCompositedChangedFieldCallback
type C_WidgetClassComputeExpandFieldCallback = Ptr Widget -> CInt -> CInt -> IO ()
type WidgetClassComputeExpandFieldCallback = Widget -> Bool -> Bool -> IO ()
dynamic_WidgetClassComputeExpandFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassComputeExpandFieldCallback -> a -> Bool -> Bool -> m ()
genClosure_WidgetClassComputeExpandFieldCallback :: MonadIO m => WidgetClassComputeExpandFieldCallback -> m (GClosure C_WidgetClassComputeExpandFieldCallback)
mk_WidgetClassComputeExpandFieldCallback :: C_WidgetClassComputeExpandFieldCallback -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)
noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback
wrap_WidgetClassComputeExpandFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)) -> WidgetClassComputeExpandFieldCallback -> C_WidgetClassComputeExpandFieldCallback
type C_WidgetClassConfigureEventFieldCallback = Ptr Widget -> Ptr EventConfigure -> IO CInt
type WidgetClassConfigureEventFieldCallback = Widget -> EventConfigure -> IO Bool
dynamic_WidgetClassConfigureEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassConfigureEventFieldCallback -> a -> EventConfigure -> m Bool
genClosure_WidgetClassConfigureEventFieldCallback :: MonadIO m => WidgetClassConfigureEventFieldCallback -> m (GClosure C_WidgetClassConfigureEventFieldCallback)
mk_WidgetClassConfigureEventFieldCallback :: C_WidgetClassConfigureEventFieldCallback -> IO (FunPtr C_WidgetClassConfigureEventFieldCallback)
noWidgetClassConfigureEventFieldCallback :: Maybe WidgetClassConfigureEventFieldCallback
wrap_WidgetClassConfigureEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassConfigureEventFieldCallback)) -> WidgetClassConfigureEventFieldCallback -> C_WidgetClassConfigureEventFieldCallback
type C_WidgetClassDamageEventFieldCallback = Ptr Widget -> Ptr EventExpose -> IO CInt
type WidgetClassDamageEventFieldCallback = Widget -> EventExpose -> IO Bool
dynamic_WidgetClassDamageEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDamageEventFieldCallback -> a -> EventExpose -> m Bool
genClosure_WidgetClassDamageEventFieldCallback :: MonadIO m => WidgetClassDamageEventFieldCallback -> m (GClosure C_WidgetClassDamageEventFieldCallback)
mk_WidgetClassDamageEventFieldCallback :: C_WidgetClassDamageEventFieldCallback -> IO (FunPtr C_WidgetClassDamageEventFieldCallback)
noWidgetClassDamageEventFieldCallback :: Maybe WidgetClassDamageEventFieldCallback
wrap_WidgetClassDamageEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDamageEventFieldCallback)) -> WidgetClassDamageEventFieldCallback -> C_WidgetClassDamageEventFieldCallback
type C_WidgetClassDeleteEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt
type WidgetClassDeleteEventFieldCallback = Widget -> EventAny -> IO Bool
dynamic_WidgetClassDeleteEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDeleteEventFieldCallback -> a -> EventAny -> m Bool
genClosure_WidgetClassDeleteEventFieldCallback :: MonadIO m => WidgetClassDeleteEventFieldCallback -> m (GClosure C_WidgetClassDeleteEventFieldCallback)
mk_WidgetClassDeleteEventFieldCallback :: C_WidgetClassDeleteEventFieldCallback -> IO (FunPtr C_WidgetClassDeleteEventFieldCallback)
noWidgetClassDeleteEventFieldCallback :: Maybe WidgetClassDeleteEventFieldCallback
wrap_WidgetClassDeleteEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)) -> WidgetClassDeleteEventFieldCallback -> C_WidgetClassDeleteEventFieldCallback
type C_WidgetClassDestroyEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt
type WidgetClassDestroyEventFieldCallback = Widget -> EventAny -> IO Bool
dynamic_WidgetClassDestroyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDestroyEventFieldCallback -> a -> EventAny -> m Bool
genClosure_WidgetClassDestroyEventFieldCallback :: MonadIO m => WidgetClassDestroyEventFieldCallback -> m (GClosure C_WidgetClassDestroyEventFieldCallback)
mk_WidgetClassDestroyEventFieldCallback :: C_WidgetClassDestroyEventFieldCallback -> IO (FunPtr C_WidgetClassDestroyEventFieldCallback)
noWidgetClassDestroyEventFieldCallback :: Maybe WidgetClassDestroyEventFieldCallback
wrap_WidgetClassDestroyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyEventFieldCallback)) -> WidgetClassDestroyEventFieldCallback -> C_WidgetClassDestroyEventFieldCallback
type C_WidgetClassDestroyFieldCallback = Ptr Widget -> IO ()
type WidgetClassDestroyFieldCallback = Widget -> IO ()
dynamic_WidgetClassDestroyFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
genClosure_WidgetClassDestroyFieldCallback :: MonadIO m => WidgetClassDestroyFieldCallback -> m (GClosure C_WidgetClassDestroyFieldCallback)
mk_WidgetClassDestroyFieldCallback :: C_WidgetClassDestroyFieldCallback -> IO (FunPtr C_WidgetClassDestroyFieldCallback)
noWidgetClassDestroyFieldCallback :: Maybe WidgetClassDestroyFieldCallback
wrap_WidgetClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyFieldCallback)) -> WidgetClassDestroyFieldCallback -> C_WidgetClassDestroyFieldCallback
type C_WidgetClassDirectionChangedFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassDirectionChangedFieldCallback = Widget -> TextDirection -> IO ()
dynamic_WidgetClassDirectionChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDirectionChangedFieldCallback -> a -> TextDirection -> m ()
genClosure_WidgetClassDirectionChangedFieldCallback :: MonadIO m => WidgetClassDirectionChangedFieldCallback -> m (GClosure C_WidgetClassDirectionChangedFieldCallback)
mk_WidgetClassDirectionChangedFieldCallback :: C_WidgetClassDirectionChangedFieldCallback -> IO (FunPtr C_WidgetClassDirectionChangedFieldCallback)
noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback
wrap_WidgetClassDirectionChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDirectionChangedFieldCallback)) -> WidgetClassDirectionChangedFieldCallback -> C_WidgetClassDirectionChangedFieldCallback
type C_WidgetClassDispatchChildPropertiesChangedFieldCallback = Ptr Widget -> Word32 -> Ptr GParamSpec -> IO ()
type WidgetClassDispatchChildPropertiesChangedFieldCallback = Widget -> Word32 -> GParamSpec -> IO ()
dynamic_WidgetClassDispatchChildPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()
genClosure_WidgetClassDispatchChildPropertiesChangedFieldCallback :: MonadIO m => WidgetClassDispatchChildPropertiesChangedFieldCallback -> m (GClosure C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
mk_WidgetClassDispatchChildPropertiesChangedFieldCallback :: C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> IO (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
noWidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback
wrap_WidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)) -> WidgetClassDispatchChildPropertiesChangedFieldCallback -> C_WidgetClassDispatchChildPropertiesChangedFieldCallback
type C_WidgetClassDragBeginFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()
type WidgetClassDragBeginFieldCallback = Widget -> DragContext -> IO ()
dynamic_WidgetClassDragBeginFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m ()
genClosure_WidgetClassDragBeginFieldCallback :: MonadIO m => WidgetClassDragBeginFieldCallback -> m (GClosure C_WidgetClassDragBeginFieldCallback)
mk_WidgetClassDragBeginFieldCallback :: C_WidgetClassDragBeginFieldCallback -> IO (FunPtr C_WidgetClassDragBeginFieldCallback)
noWidgetClassDragBeginFieldCallback :: Maybe WidgetClassDragBeginFieldCallback
wrap_WidgetClassDragBeginFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)) -> WidgetClassDragBeginFieldCallback -> C_WidgetClassDragBeginFieldCallback
type C_WidgetClassDragDataDeleteFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()
type WidgetClassDragDataDeleteFieldCallback = Widget -> DragContext -> IO ()
dynamic_WidgetClassDragDataDeleteFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataDeleteFieldCallback -> a -> b -> m ()
genClosure_WidgetClassDragDataDeleteFieldCallback :: MonadIO m => WidgetClassDragDataDeleteFieldCallback -> m (GClosure C_WidgetClassDragDataDeleteFieldCallback)
mk_WidgetClassDragDataDeleteFieldCallback :: C_WidgetClassDragDataDeleteFieldCallback -> IO (FunPtr C_WidgetClassDragDataDeleteFieldCallback)
noWidgetClassDragDataDeleteFieldCallback :: Maybe WidgetClassDragDataDeleteFieldCallback
wrap_WidgetClassDragDataDeleteFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataDeleteFieldCallback)) -> WidgetClassDragDataDeleteFieldCallback -> C_WidgetClassDragDataDeleteFieldCallback
type C_WidgetClassDragDataGetFieldCallback = Ptr Widget -> Ptr DragContext -> Ptr SelectionData -> Word32 -> Word32 -> IO ()
type WidgetClassDragDataGetFieldCallback = Widget -> DragContext -> SelectionData -> Word32 -> Word32 -> IO ()
dynamic_WidgetClassDragDataGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataGetFieldCallback -> a -> b -> SelectionData -> Word32 -> Word32 -> m ()
genClosure_WidgetClassDragDataGetFieldCallback :: MonadIO m => WidgetClassDragDataGetFieldCallback -> m (GClosure C_WidgetClassDragDataGetFieldCallback)
mk_WidgetClassDragDataGetFieldCallback :: C_WidgetClassDragDataGetFieldCallback -> IO (FunPtr C_WidgetClassDragDataGetFieldCallback)
noWidgetClassDragDataGetFieldCallback :: Maybe WidgetClassDragDataGetFieldCallback
wrap_WidgetClassDragDataGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)) -> WidgetClassDragDataGetFieldCallback -> C_WidgetClassDragDataGetFieldCallback
type C_WidgetClassDragDataReceivedFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Ptr SelectionData -> Word32 -> Word32 -> IO ()
type WidgetClassDragDataReceivedFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> IO ()
dynamic_WidgetClassDragDataReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataReceivedFieldCallback -> a -> b -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> m ()
genClosure_WidgetClassDragDataReceivedFieldCallback :: MonadIO m => WidgetClassDragDataReceivedFieldCallback -> m (GClosure C_WidgetClassDragDataReceivedFieldCallback)
mk_WidgetClassDragDataReceivedFieldCallback :: C_WidgetClassDragDataReceivedFieldCallback -> IO (FunPtr C_WidgetClassDragDataReceivedFieldCallback)
noWidgetClassDragDataReceivedFieldCallback :: Maybe WidgetClassDragDataReceivedFieldCallback
wrap_WidgetClassDragDataReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)) -> WidgetClassDragDataReceivedFieldCallback -> C_WidgetClassDragDataReceivedFieldCallback
type C_WidgetClassDragDropFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt
type WidgetClassDragDropFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool
dynamic_WidgetClassDragDropFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDropFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool
genClosure_WidgetClassDragDropFieldCallback :: MonadIO m => WidgetClassDragDropFieldCallback -> m (GClosure C_WidgetClassDragDropFieldCallback)
mk_WidgetClassDragDropFieldCallback :: C_WidgetClassDragDropFieldCallback -> IO (FunPtr C_WidgetClassDragDropFieldCallback)
noWidgetClassDragDropFieldCallback :: Maybe WidgetClassDragDropFieldCallback
wrap_WidgetClassDragDropFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDropFieldCallback)) -> WidgetClassDragDropFieldCallback -> C_WidgetClassDragDropFieldCallback
type C_WidgetClassDragEndFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()
type WidgetClassDragEndFieldCallback = Widget -> DragContext -> IO ()
dynamic_WidgetClassDragEndFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragEndFieldCallback -> a -> b -> m ()
genClosure_WidgetClassDragEndFieldCallback :: MonadIO m => WidgetClassDragEndFieldCallback -> m (GClosure C_WidgetClassDragEndFieldCallback)
mk_WidgetClassDragEndFieldCallback :: C_WidgetClassDragEndFieldCallback -> IO (FunPtr C_WidgetClassDragEndFieldCallback)
noWidgetClassDragEndFieldCallback :: Maybe WidgetClassDragEndFieldCallback
wrap_WidgetClassDragEndFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragEndFieldCallback)) -> WidgetClassDragEndFieldCallback -> C_WidgetClassDragEndFieldCallback
type C_WidgetClassDragFailedFieldCallback = Ptr Widget -> Ptr DragContext -> CUInt -> IO CInt
type WidgetClassDragFailedFieldCallback = Widget -> DragContext -> DragResult -> IO Bool
dynamic_WidgetClassDragFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragFailedFieldCallback -> a -> b -> DragResult -> m Bool
genClosure_WidgetClassDragFailedFieldCallback :: MonadIO m => WidgetClassDragFailedFieldCallback -> m (GClosure C_WidgetClassDragFailedFieldCallback)
mk_WidgetClassDragFailedFieldCallback :: C_WidgetClassDragFailedFieldCallback -> IO (FunPtr C_WidgetClassDragFailedFieldCallback)
noWidgetClassDragFailedFieldCallback :: Maybe WidgetClassDragFailedFieldCallback
wrap_WidgetClassDragFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)) -> WidgetClassDragFailedFieldCallback -> C_WidgetClassDragFailedFieldCallback
type C_WidgetClassDragLeaveFieldCallback = Ptr Widget -> Ptr DragContext -> Word32 -> IO ()
type WidgetClassDragLeaveFieldCallback = Widget -> DragContext -> Word32 -> IO ()
dynamic_WidgetClassDragLeaveFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragLeaveFieldCallback -> a -> b -> Word32 -> m ()
genClosure_WidgetClassDragLeaveFieldCallback :: MonadIO m => WidgetClassDragLeaveFieldCallback -> m (GClosure C_WidgetClassDragLeaveFieldCallback)
mk_WidgetClassDragLeaveFieldCallback :: C_WidgetClassDragLeaveFieldCallback -> IO (FunPtr C_WidgetClassDragLeaveFieldCallback)
noWidgetClassDragLeaveFieldCallback :: Maybe WidgetClassDragLeaveFieldCallback
wrap_WidgetClassDragLeaveFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)) -> WidgetClassDragLeaveFieldCallback -> C_WidgetClassDragLeaveFieldCallback
type C_WidgetClassDragMotionFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt
type WidgetClassDragMotionFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool
dynamic_WidgetClassDragMotionFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragMotionFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool
genClosure_WidgetClassDragMotionFieldCallback :: MonadIO m => WidgetClassDragMotionFieldCallback -> m (GClosure C_WidgetClassDragMotionFieldCallback)
mk_WidgetClassDragMotionFieldCallback :: C_WidgetClassDragMotionFieldCallback -> IO (FunPtr C_WidgetClassDragMotionFieldCallback)
noWidgetClassDragMotionFieldCallback :: Maybe WidgetClassDragMotionFieldCallback
wrap_WidgetClassDragMotionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)) -> WidgetClassDragMotionFieldCallback -> C_WidgetClassDragMotionFieldCallback
type C_WidgetClassDrawFieldCallback = Ptr Widget -> Ptr Context -> IO CInt
type WidgetClassDrawFieldCallback = Widget -> Context -> IO Bool
dynamic_WidgetClassDrawFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDrawFieldCallback -> a -> Context -> m Bool
genClosure_WidgetClassDrawFieldCallback :: MonadIO m => WidgetClassDrawFieldCallback -> m (GClosure C_WidgetClassDrawFieldCallback)
mk_WidgetClassDrawFieldCallback :: C_WidgetClassDrawFieldCallback -> IO (FunPtr C_WidgetClassDrawFieldCallback)
noWidgetClassDrawFieldCallback :: Maybe WidgetClassDrawFieldCallback
wrap_WidgetClassDrawFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDrawFieldCallback)) -> WidgetClassDrawFieldCallback -> C_WidgetClassDrawFieldCallback
type C_WidgetClassEnterNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt
type WidgetClassEnterNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool
dynamic_WidgetClassEnterNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> a -> EventCrossing -> m Bool
genClosure_WidgetClassEnterNotifyEventFieldCallback :: MonadIO m => WidgetClassEnterNotifyEventFieldCallback -> m (GClosure C_WidgetClassEnterNotifyEventFieldCallback)
mk_WidgetClassEnterNotifyEventFieldCallback :: C_WidgetClassEnterNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)
noWidgetClassEnterNotifyEventFieldCallback :: Maybe WidgetClassEnterNotifyEventFieldCallback
wrap_WidgetClassEnterNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)) -> WidgetClassEnterNotifyEventFieldCallback -> C_WidgetClassEnterNotifyEventFieldCallback
type C_WidgetClassEventFieldCallback = Ptr Widget -> Ptr Event -> IO CInt
type WidgetClassEventFieldCallback = Widget -> Event -> IO Bool
dynamic_WidgetClassEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassEventFieldCallback -> a -> Event -> m Bool
genClosure_WidgetClassEventFieldCallback :: MonadIO m => WidgetClassEventFieldCallback -> m (GClosure C_WidgetClassEventFieldCallback)
mk_WidgetClassEventFieldCallback :: C_WidgetClassEventFieldCallback -> IO (FunPtr C_WidgetClassEventFieldCallback)
noWidgetClassEventFieldCallback :: Maybe WidgetClassEventFieldCallback
wrap_WidgetClassEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEventFieldCallback)) -> WidgetClassEventFieldCallback -> C_WidgetClassEventFieldCallback
type C_WidgetClassFocusFieldCallback = Ptr Widget -> CUInt -> IO CInt
type WidgetClassFocusFieldCallback = Widget -> DirectionType -> IO Bool
dynamic_WidgetClassFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusFieldCallback -> a -> DirectionType -> m Bool
genClosure_WidgetClassFocusFieldCallback :: MonadIO m => WidgetClassFocusFieldCallback -> m (GClosure C_WidgetClassFocusFieldCallback)
mk_WidgetClassFocusFieldCallback :: C_WidgetClassFocusFieldCallback -> IO (FunPtr C_WidgetClassFocusFieldCallback)
noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback
wrap_WidgetClassFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusFieldCallback)) -> WidgetClassFocusFieldCallback -> C_WidgetClassFocusFieldCallback
type C_WidgetClassFocusInEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt
type WidgetClassFocusInEventFieldCallback = Widget -> EventFocus -> IO Bool
dynamic_WidgetClassFocusInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusInEventFieldCallback -> a -> EventFocus -> m Bool
genClosure_WidgetClassFocusInEventFieldCallback :: MonadIO m => WidgetClassFocusInEventFieldCallback -> m (GClosure C_WidgetClassFocusInEventFieldCallback)
mk_WidgetClassFocusInEventFieldCallback :: C_WidgetClassFocusInEventFieldCallback -> IO (FunPtr C_WidgetClassFocusInEventFieldCallback)
noWidgetClassFocusInEventFieldCallback :: Maybe WidgetClassFocusInEventFieldCallback
wrap_WidgetClassFocusInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)) -> WidgetClassFocusInEventFieldCallback -> C_WidgetClassFocusInEventFieldCallback
type C_WidgetClassFocusOutEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt
type WidgetClassFocusOutEventFieldCallback = Widget -> EventFocus -> IO Bool
dynamic_WidgetClassFocusOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusOutEventFieldCallback -> a -> EventFocus -> m Bool
genClosure_WidgetClassFocusOutEventFieldCallback :: MonadIO m => WidgetClassFocusOutEventFieldCallback -> m (GClosure C_WidgetClassFocusOutEventFieldCallback)
mk_WidgetClassFocusOutEventFieldCallback :: C_WidgetClassFocusOutEventFieldCallback -> IO (FunPtr C_WidgetClassFocusOutEventFieldCallback)
noWidgetClassFocusOutEventFieldCallback :: Maybe WidgetClassFocusOutEventFieldCallback
wrap_WidgetClassFocusOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusOutEventFieldCallback)) -> WidgetClassFocusOutEventFieldCallback -> C_WidgetClassFocusOutEventFieldCallback
type C_WidgetClassGetAccessibleFieldCallback = Ptr Widget -> IO (Ptr Object)
type WidgetClassGetAccessibleFieldCallback = Widget -> IO Object
dynamic_WidgetClassGetAccessibleFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetAccessibleFieldCallback -> a -> m Object
genClosure_WidgetClassGetAccessibleFieldCallback :: MonadIO m => WidgetClassGetAccessibleFieldCallback -> m (GClosure C_WidgetClassGetAccessibleFieldCallback)
mk_WidgetClassGetAccessibleFieldCallback :: C_WidgetClassGetAccessibleFieldCallback -> IO (FunPtr C_WidgetClassGetAccessibleFieldCallback)
noWidgetClassGetAccessibleFieldCallback :: Maybe WidgetClassGetAccessibleFieldCallback
wrap_WidgetClassGetAccessibleFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)) -> WidgetClassGetAccessibleFieldCallback -> C_WidgetClassGetAccessibleFieldCallback
type C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
type WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback = Widget -> Int32 -> IO (Int32, Int32, Int32, Int32)
dynamic_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> a -> Int32 -> m (Int32, Int32, Int32, Int32)
genClosure_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
mk_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
noWidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
wrap_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)) -> WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
type C_WidgetClassGetPreferredHeightFieldCallback = Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()
type WidgetClassGetPreferredHeightFieldCallback = Widget -> IO (Int32, Int32)
dynamic_WidgetClassGetPreferredHeightFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> a -> m (Int32, Int32)
genClosure_WidgetClassGetPreferredHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightFieldCallback)
mk_WidgetClassGetPreferredHeightFieldCallback :: C_WidgetClassGetPreferredHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)
noWidgetClassGetPreferredHeightFieldCallback :: Maybe WidgetClassGetPreferredHeightFieldCallback
wrap_WidgetClassGetPreferredHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)) -> WidgetClassGetPreferredHeightFieldCallback -> C_WidgetClassGetPreferredHeightFieldCallback
type C_WidgetClassGetPreferredHeightForWidthFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
type WidgetClassGetPreferredHeightForWidthFieldCallback = Widget -> Int32 -> IO (Int32, Int32)
dynamic_WidgetClassGetPreferredHeightForWidthFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback -> a -> Int32 -> m (Int32, Int32)
genClosure_WidgetClassGetPreferredHeightForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightForWidthFieldCallback)
mk_WidgetClassGetPreferredHeightForWidthFieldCallback :: C_WidgetClassGetPreferredHeightForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)
noWidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightForWidthFieldCallback
wrap_WidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)) -> WidgetClassGetPreferredHeightForWidthFieldCallback -> C_WidgetClassGetPreferredHeightForWidthFieldCallback
type C_WidgetClassGetPreferredWidthFieldCallback = Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()
type WidgetClassGetPreferredWidthFieldCallback = Widget -> IO (Int32, Int32)
dynamic_WidgetClassGetPreferredWidthFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredWidthFieldCallback -> a -> m (Int32, Int32)
genClosure_WidgetClassGetPreferredWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthFieldCallback)
mk_WidgetClassGetPreferredWidthFieldCallback :: C_WidgetClassGetPreferredWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)
noWidgetClassGetPreferredWidthFieldCallback :: Maybe WidgetClassGetPreferredWidthFieldCallback
wrap_WidgetClassGetPreferredWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)) -> WidgetClassGetPreferredWidthFieldCallback -> C_WidgetClassGetPreferredWidthFieldCallback
type C_WidgetClassGetPreferredWidthForHeightFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()
type WidgetClassGetPreferredWidthForHeightFieldCallback = Widget -> Int32 -> IO (Int32, Int32)
dynamic_WidgetClassGetPreferredWidthForHeightFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback -> a -> Int32 -> m (Int32, Int32)
genClosure_WidgetClassGetPreferredWidthForHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthForHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthForHeightFieldCallback)
mk_WidgetClassGetPreferredWidthForHeightFieldCallback :: C_WidgetClassGetPreferredWidthForHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)
noWidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe WidgetClassGetPreferredWidthForHeightFieldCallback
wrap_WidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)) -> WidgetClassGetPreferredWidthForHeightFieldCallback -> C_WidgetClassGetPreferredWidthForHeightFieldCallback
type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt
type WidgetClassGetRequestModeFieldCallback = Widget -> IO SizeRequestMode
dynamic_WidgetClassGetRequestModeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetRequestModeFieldCallback -> a -> m SizeRequestMode
genClosure_WidgetClassGetRequestModeFieldCallback :: MonadIO m => WidgetClassGetRequestModeFieldCallback -> m (GClosure C_WidgetClassGetRequestModeFieldCallback)
mk_WidgetClassGetRequestModeFieldCallback :: C_WidgetClassGetRequestModeFieldCallback -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)
noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback
wrap_WidgetClassGetRequestModeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)) -> WidgetClassGetRequestModeFieldCallback -> C_WidgetClassGetRequestModeFieldCallback
type C_WidgetClassGrabBrokenEventFieldCallback = Ptr Widget -> Ptr EventGrabBroken -> IO CInt
type WidgetClassGrabBrokenEventFieldCallback = Widget -> EventGrabBroken -> IO Bool
dynamic_WidgetClassGrabBrokenEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> a -> EventGrabBroken -> m Bool
genClosure_WidgetClassGrabBrokenEventFieldCallback :: MonadIO m => WidgetClassGrabBrokenEventFieldCallback -> m (GClosure C_WidgetClassGrabBrokenEventFieldCallback)
mk_WidgetClassGrabBrokenEventFieldCallback :: C_WidgetClassGrabBrokenEventFieldCallback -> IO (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)
noWidgetClassGrabBrokenEventFieldCallback :: Maybe WidgetClassGrabBrokenEventFieldCallback
wrap_WidgetClassGrabBrokenEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)) -> WidgetClassGrabBrokenEventFieldCallback -> C_WidgetClassGrabBrokenEventFieldCallback
type C_WidgetClassGrabFocusFieldCallback = Ptr Widget -> IO ()
type WidgetClassGrabFocusFieldCallback = Widget -> IO ()
dynamic_WidgetClassGrabFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabFocusFieldCallback -> a -> m ()
genClosure_WidgetClassGrabFocusFieldCallback :: MonadIO m => WidgetClassGrabFocusFieldCallback -> m (GClosure C_WidgetClassGrabFocusFieldCallback)
mk_WidgetClassGrabFocusFieldCallback :: C_WidgetClassGrabFocusFieldCallback -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)
noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback
wrap_WidgetClassGrabFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)) -> WidgetClassGrabFocusFieldCallback -> C_WidgetClassGrabFocusFieldCallback
type C_WidgetClassGrabNotifyFieldCallback = Ptr Widget -> CInt -> IO ()
type WidgetClassGrabNotifyFieldCallback = Widget -> Bool -> IO ()
dynamic_WidgetClassGrabNotifyFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabNotifyFieldCallback -> a -> Bool -> m ()
genClosure_WidgetClassGrabNotifyFieldCallback :: MonadIO m => WidgetClassGrabNotifyFieldCallback -> m (GClosure C_WidgetClassGrabNotifyFieldCallback)
mk_WidgetClassGrabNotifyFieldCallback :: C_WidgetClassGrabNotifyFieldCallback -> IO (FunPtr C_WidgetClassGrabNotifyFieldCallback)
noWidgetClassGrabNotifyFieldCallback :: Maybe WidgetClassGrabNotifyFieldCallback
wrap_WidgetClassGrabNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)) -> WidgetClassGrabNotifyFieldCallback -> C_WidgetClassGrabNotifyFieldCallback
type C_WidgetClassHideFieldCallback = Ptr Widget -> IO ()
type WidgetClassHideFieldCallback = Widget -> IO ()
dynamic_WidgetClassHideFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassHideFieldCallback -> a -> m ()
genClosure_WidgetClassHideFieldCallback :: MonadIO m => WidgetClassHideFieldCallback -> m (GClosure C_WidgetClassHideFieldCallback)
mk_WidgetClassHideFieldCallback :: C_WidgetClassHideFieldCallback -> IO (FunPtr C_WidgetClassHideFieldCallback)
noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback
wrap_WidgetClassHideFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHideFieldCallback)) -> WidgetClassHideFieldCallback -> C_WidgetClassHideFieldCallback
type C_WidgetClassHierarchyChangedFieldCallback = Ptr Widget -> Ptr Widget -> IO ()
type WidgetClassHierarchyChangedFieldCallback = Widget -> Widget -> IO ()
dynamic_WidgetClassHierarchyChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassHierarchyChangedFieldCallback -> a -> b -> m ()
genClosure_WidgetClassHierarchyChangedFieldCallback :: MonadIO m => WidgetClassHierarchyChangedFieldCallback -> m (GClosure C_WidgetClassHierarchyChangedFieldCallback)
mk_WidgetClassHierarchyChangedFieldCallback :: C_WidgetClassHierarchyChangedFieldCallback -> IO (FunPtr C_WidgetClassHierarchyChangedFieldCallback)
noWidgetClassHierarchyChangedFieldCallback :: Maybe WidgetClassHierarchyChangedFieldCallback
wrap_WidgetClassHierarchyChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHierarchyChangedFieldCallback)) -> WidgetClassHierarchyChangedFieldCallback -> C_WidgetClassHierarchyChangedFieldCallback
type C_WidgetClassKeyPressEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt
type WidgetClassKeyPressEventFieldCallback = Widget -> EventKey -> IO Bool
dynamic_WidgetClassKeyPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyPressEventFieldCallback -> a -> EventKey -> m Bool
genClosure_WidgetClassKeyPressEventFieldCallback :: MonadIO m => WidgetClassKeyPressEventFieldCallback -> m (GClosure C_WidgetClassKeyPressEventFieldCallback)
mk_WidgetClassKeyPressEventFieldCallback :: C_WidgetClassKeyPressEventFieldCallback -> IO (FunPtr C_WidgetClassKeyPressEventFieldCallback)
noWidgetClassKeyPressEventFieldCallback :: Maybe WidgetClassKeyPressEventFieldCallback
wrap_WidgetClassKeyPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)) -> WidgetClassKeyPressEventFieldCallback -> C_WidgetClassKeyPressEventFieldCallback
type C_WidgetClassKeyReleaseEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt
type WidgetClassKeyReleaseEventFieldCallback = Widget -> EventKey -> IO Bool
dynamic_WidgetClassKeyReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyReleaseEventFieldCallback -> a -> EventKey -> m Bool
genClosure_WidgetClassKeyReleaseEventFieldCallback :: MonadIO m => WidgetClassKeyReleaseEventFieldCallback -> m (GClosure C_WidgetClassKeyReleaseEventFieldCallback)
mk_WidgetClassKeyReleaseEventFieldCallback :: C_WidgetClassKeyReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)
noWidgetClassKeyReleaseEventFieldCallback :: Maybe WidgetClassKeyReleaseEventFieldCallback
wrap_WidgetClassKeyReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)) -> WidgetClassKeyReleaseEventFieldCallback -> C_WidgetClassKeyReleaseEventFieldCallback
type C_WidgetClassKeynavFailedFieldCallback = Ptr Widget -> CUInt -> IO CInt
type WidgetClassKeynavFailedFieldCallback = Widget -> DirectionType -> IO Bool
dynamic_WidgetClassKeynavFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeynavFailedFieldCallback -> a -> DirectionType -> m Bool
genClosure_WidgetClassKeynavFailedFieldCallback :: MonadIO m => WidgetClassKeynavFailedFieldCallback -> m (GClosure C_WidgetClassKeynavFailedFieldCallback)
mk_WidgetClassKeynavFailedFieldCallback :: C_WidgetClassKeynavFailedFieldCallback -> IO (FunPtr C_WidgetClassKeynavFailedFieldCallback)
noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback
wrap_WidgetClassKeynavFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeynavFailedFieldCallback)) -> WidgetClassKeynavFailedFieldCallback -> C_WidgetClassKeynavFailedFieldCallback
type C_WidgetClassLeaveNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt
type WidgetClassLeaveNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool
dynamic_WidgetClassLeaveNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassLeaveNotifyEventFieldCallback -> a -> EventCrossing -> m Bool
genClosure_WidgetClassLeaveNotifyEventFieldCallback :: MonadIO m => WidgetClassLeaveNotifyEventFieldCallback -> m (GClosure C_WidgetClassLeaveNotifyEventFieldCallback)
mk_WidgetClassLeaveNotifyEventFieldCallback :: C_WidgetClassLeaveNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)
noWidgetClassLeaveNotifyEventFieldCallback :: Maybe WidgetClassLeaveNotifyEventFieldCallback
wrap_WidgetClassLeaveNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)) -> WidgetClassLeaveNotifyEventFieldCallback -> C_WidgetClassLeaveNotifyEventFieldCallback
type C_WidgetClassMapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt
type WidgetClassMapEventFieldCallback = Widget -> EventAny -> IO Bool
dynamic_WidgetClassMapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapEventFieldCallback -> a -> EventAny -> m Bool
genClosure_WidgetClassMapEventFieldCallback :: MonadIO m => WidgetClassMapEventFieldCallback -> m (GClosure C_WidgetClassMapEventFieldCallback)
mk_WidgetClassMapEventFieldCallback :: C_WidgetClassMapEventFieldCallback -> IO (FunPtr C_WidgetClassMapEventFieldCallback)
noWidgetClassMapEventFieldCallback :: Maybe WidgetClassMapEventFieldCallback
wrap_WidgetClassMapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapEventFieldCallback)) -> WidgetClassMapEventFieldCallback -> C_WidgetClassMapEventFieldCallback
type C_WidgetClassMapFieldCallback = Ptr Widget -> IO ()
type WidgetClassMapFieldCallback = Widget -> IO ()
dynamic_WidgetClassMapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapFieldCallback -> a -> m ()
genClosure_WidgetClassMapFieldCallback :: MonadIO m => WidgetClassMapFieldCallback -> m (GClosure C_WidgetClassMapFieldCallback)
mk_WidgetClassMapFieldCallback :: C_WidgetClassMapFieldCallback -> IO (FunPtr C_WidgetClassMapFieldCallback)
noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback
wrap_WidgetClassMapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapFieldCallback)) -> WidgetClassMapFieldCallback -> C_WidgetClassMapFieldCallback
type C_WidgetClassMnemonicActivateFieldCallback = Ptr Widget -> CInt -> IO CInt
type WidgetClassMnemonicActivateFieldCallback = Widget -> Bool -> IO Bool
dynamic_WidgetClassMnemonicActivateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMnemonicActivateFieldCallback -> a -> Bool -> m Bool
genClosure_WidgetClassMnemonicActivateFieldCallback :: MonadIO m => WidgetClassMnemonicActivateFieldCallback -> m (GClosure C_WidgetClassMnemonicActivateFieldCallback)
mk_WidgetClassMnemonicActivateFieldCallback :: C_WidgetClassMnemonicActivateFieldCallback -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback
wrap_WidgetClassMnemonicActivateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)) -> WidgetClassMnemonicActivateFieldCallback -> C_WidgetClassMnemonicActivateFieldCallback
type C_WidgetClassMotionNotifyEventFieldCallback = Ptr Widget -> Ptr EventMotion -> IO CInt
type WidgetClassMotionNotifyEventFieldCallback = Widget -> EventMotion -> IO Bool
dynamic_WidgetClassMotionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> a -> EventMotion -> m Bool
genClosure_WidgetClassMotionNotifyEventFieldCallback :: MonadIO m => WidgetClassMotionNotifyEventFieldCallback -> m (GClosure C_WidgetClassMotionNotifyEventFieldCallback)
mk_WidgetClassMotionNotifyEventFieldCallback :: C_WidgetClassMotionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)
noWidgetClassMotionNotifyEventFieldCallback :: Maybe WidgetClassMotionNotifyEventFieldCallback
wrap_WidgetClassMotionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)) -> WidgetClassMotionNotifyEventFieldCallback -> C_WidgetClassMotionNotifyEventFieldCallback
type C_WidgetClassMoveFocusFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassMoveFocusFieldCallback = Widget -> DirectionType -> IO ()
dynamic_WidgetClassMoveFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMoveFocusFieldCallback -> a -> DirectionType -> m ()
genClosure_WidgetClassMoveFocusFieldCallback :: MonadIO m => WidgetClassMoveFocusFieldCallback -> m (GClosure C_WidgetClassMoveFocusFieldCallback)
mk_WidgetClassMoveFocusFieldCallback :: C_WidgetClassMoveFocusFieldCallback -> IO (FunPtr C_WidgetClassMoveFocusFieldCallback)
noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback
wrap_WidgetClassMoveFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMoveFocusFieldCallback)) -> WidgetClassMoveFocusFieldCallback -> C_WidgetClassMoveFocusFieldCallback
type C_WidgetClassParentSetFieldCallback = Ptr Widget -> Ptr Widget -> IO ()
type WidgetClassParentSetFieldCallback = Widget -> Widget -> IO ()
dynamic_WidgetClassParentSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassParentSetFieldCallback -> a -> b -> m ()
genClosure_WidgetClassParentSetFieldCallback :: MonadIO m => WidgetClassParentSetFieldCallback -> m (GClosure C_WidgetClassParentSetFieldCallback)
mk_WidgetClassParentSetFieldCallback :: C_WidgetClassParentSetFieldCallback -> IO (FunPtr C_WidgetClassParentSetFieldCallback)
noWidgetClassParentSetFieldCallback :: Maybe WidgetClassParentSetFieldCallback
wrap_WidgetClassParentSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassParentSetFieldCallback)) -> WidgetClassParentSetFieldCallback -> C_WidgetClassParentSetFieldCallback
type C_WidgetClassPopupMenuFieldCallback = Ptr Widget -> IO CInt
type WidgetClassPopupMenuFieldCallback = Widget -> IO Bool
dynamic_WidgetClassPopupMenuFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassPopupMenuFieldCallback -> a -> m Bool
genClosure_WidgetClassPopupMenuFieldCallback :: MonadIO m => WidgetClassPopupMenuFieldCallback -> m (GClosure C_WidgetClassPopupMenuFieldCallback)
mk_WidgetClassPopupMenuFieldCallback :: C_WidgetClassPopupMenuFieldCallback -> IO (FunPtr C_WidgetClassPopupMenuFieldCallback)
noWidgetClassPopupMenuFieldCallback :: Maybe WidgetClassPopupMenuFieldCallback
wrap_WidgetClassPopupMenuFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)) -> WidgetClassPopupMenuFieldCallback -> C_WidgetClassPopupMenuFieldCallback
type C_WidgetClassPropertyNotifyEventFieldCallback = Ptr Widget -> Ptr EventProperty -> IO CInt
type WidgetClassPropertyNotifyEventFieldCallback = Widget -> EventProperty -> IO Bool
dynamic_WidgetClassPropertyNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> a -> EventProperty -> m Bool
genClosure_WidgetClassPropertyNotifyEventFieldCallback :: MonadIO m => WidgetClassPropertyNotifyEventFieldCallback -> m (GClosure C_WidgetClassPropertyNotifyEventFieldCallback)
mk_WidgetClassPropertyNotifyEventFieldCallback :: C_WidgetClassPropertyNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)
noWidgetClassPropertyNotifyEventFieldCallback :: Maybe WidgetClassPropertyNotifyEventFieldCallback
wrap_WidgetClassPropertyNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)) -> WidgetClassPropertyNotifyEventFieldCallback -> C_WidgetClassPropertyNotifyEventFieldCallback
type C_WidgetClassProximityInEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt
type WidgetClassProximityInEventFieldCallback = Widget -> EventProximity -> IO Bool
dynamic_WidgetClassProximityInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityInEventFieldCallback -> a -> EventProximity -> m Bool
genClosure_WidgetClassProximityInEventFieldCallback :: MonadIO m => WidgetClassProximityInEventFieldCallback -> m (GClosure C_WidgetClassProximityInEventFieldCallback)
mk_WidgetClassProximityInEventFieldCallback :: C_WidgetClassProximityInEventFieldCallback -> IO (FunPtr C_WidgetClassProximityInEventFieldCallback)
noWidgetClassProximityInEventFieldCallback :: Maybe WidgetClassProximityInEventFieldCallback
wrap_WidgetClassProximityInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)) -> WidgetClassProximityInEventFieldCallback -> C_WidgetClassProximityInEventFieldCallback
type C_WidgetClassProximityOutEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt
type WidgetClassProximityOutEventFieldCallback = Widget -> EventProximity -> IO Bool
dynamic_WidgetClassProximityOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityOutEventFieldCallback -> a -> EventProximity -> m Bool
genClosure_WidgetClassProximityOutEventFieldCallback :: MonadIO m => WidgetClassProximityOutEventFieldCallback -> m (GClosure C_WidgetClassProximityOutEventFieldCallback)
mk_WidgetClassProximityOutEventFieldCallback :: C_WidgetClassProximityOutEventFieldCallback -> IO (FunPtr C_WidgetClassProximityOutEventFieldCallback)
noWidgetClassProximityOutEventFieldCallback :: Maybe WidgetClassProximityOutEventFieldCallback
wrap_WidgetClassProximityOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityOutEventFieldCallback)) -> WidgetClassProximityOutEventFieldCallback -> C_WidgetClassProximityOutEventFieldCallback
type C_WidgetClassQueryTooltipFieldCallback = Ptr Widget -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> IO CInt
type WidgetClassQueryTooltipFieldCallback = Widget -> Int32 -> Int32 -> Bool -> Tooltip -> IO Bool
dynamic_WidgetClassQueryTooltipFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsTooltip b) => FunPtr C_WidgetClassQueryTooltipFieldCallback -> a -> Int32 -> Int32 -> Bool -> b -> m Bool
genClosure_WidgetClassQueryTooltipFieldCallback :: MonadIO m => WidgetClassQueryTooltipFieldCallback -> m (GClosure C_WidgetClassQueryTooltipFieldCallback)
mk_WidgetClassQueryTooltipFieldCallback :: C_WidgetClassQueryTooltipFieldCallback -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)
noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback
wrap_WidgetClassQueryTooltipFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)) -> WidgetClassQueryTooltipFieldCallback -> C_WidgetClassQueryTooltipFieldCallback
type C_WidgetClassQueueDrawRegionFieldCallback = Ptr Widget -> Ptr Region -> IO ()
type WidgetClassQueueDrawRegionFieldCallback = Widget -> Region -> IO ()
dynamic_WidgetClassQueueDrawRegionFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> a -> Region -> m ()
genClosure_WidgetClassQueueDrawRegionFieldCallback :: MonadIO m => WidgetClassQueueDrawRegionFieldCallback -> m (GClosure C_WidgetClassQueueDrawRegionFieldCallback)
mk_WidgetClassQueueDrawRegionFieldCallback :: C_WidgetClassQueueDrawRegionFieldCallback -> IO (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)
noWidgetClassQueueDrawRegionFieldCallback :: Maybe WidgetClassQueueDrawRegionFieldCallback
wrap_WidgetClassQueueDrawRegionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)) -> WidgetClassQueueDrawRegionFieldCallback -> C_WidgetClassQueueDrawRegionFieldCallback
type C_WidgetClassRealizeFieldCallback = Ptr Widget -> IO ()
type WidgetClassRealizeFieldCallback = Widget -> IO ()
dynamic_WidgetClassRealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassRealizeFieldCallback -> a -> m ()
genClosure_WidgetClassRealizeFieldCallback :: MonadIO m => WidgetClassRealizeFieldCallback -> m (GClosure C_WidgetClassRealizeFieldCallback)
mk_WidgetClassRealizeFieldCallback :: C_WidgetClassRealizeFieldCallback -> IO (FunPtr C_WidgetClassRealizeFieldCallback)
noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback
wrap_WidgetClassRealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRealizeFieldCallback)) -> WidgetClassRealizeFieldCallback -> C_WidgetClassRealizeFieldCallback
type C_WidgetClassScreenChangedFieldCallback = Ptr Widget -> Ptr Screen -> IO ()
type WidgetClassScreenChangedFieldCallback = Widget -> Screen -> IO ()
dynamic_WidgetClassScreenChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsScreen b) => FunPtr C_WidgetClassScreenChangedFieldCallback -> a -> b -> m ()
genClosure_WidgetClassScreenChangedFieldCallback :: MonadIO m => WidgetClassScreenChangedFieldCallback -> m (GClosure C_WidgetClassScreenChangedFieldCallback)
mk_WidgetClassScreenChangedFieldCallback :: C_WidgetClassScreenChangedFieldCallback -> IO (FunPtr C_WidgetClassScreenChangedFieldCallback)
noWidgetClassScreenChangedFieldCallback :: Maybe WidgetClassScreenChangedFieldCallback
wrap_WidgetClassScreenChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)) -> WidgetClassScreenChangedFieldCallback -> C_WidgetClassScreenChangedFieldCallback
type C_WidgetClassScrollEventFieldCallback = Ptr Widget -> Ptr EventScroll -> IO CInt
type WidgetClassScrollEventFieldCallback = Widget -> EventScroll -> IO Bool
dynamic_WidgetClassScrollEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassScrollEventFieldCallback -> a -> EventScroll -> m Bool
genClosure_WidgetClassScrollEventFieldCallback :: MonadIO m => WidgetClassScrollEventFieldCallback -> m (GClosure C_WidgetClassScrollEventFieldCallback)
mk_WidgetClassScrollEventFieldCallback :: C_WidgetClassScrollEventFieldCallback -> IO (FunPtr C_WidgetClassScrollEventFieldCallback)
noWidgetClassScrollEventFieldCallback :: Maybe WidgetClassScrollEventFieldCallback
wrap_WidgetClassScrollEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScrollEventFieldCallback)) -> WidgetClassScrollEventFieldCallback -> C_WidgetClassScrollEventFieldCallback
type C_WidgetClassSelectionClearEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt
type WidgetClassSelectionClearEventFieldCallback = Widget -> EventSelection -> IO Bool
dynamic_WidgetClassSelectionClearEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionClearEventFieldCallback -> a -> EventSelection -> m Bool
genClosure_WidgetClassSelectionClearEventFieldCallback :: MonadIO m => WidgetClassSelectionClearEventFieldCallback -> m (GClosure C_WidgetClassSelectionClearEventFieldCallback)
mk_WidgetClassSelectionClearEventFieldCallback :: C_WidgetClassSelectionClearEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionClearEventFieldCallback)
noWidgetClassSelectionClearEventFieldCallback :: Maybe WidgetClassSelectionClearEventFieldCallback
wrap_WidgetClassSelectionClearEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)) -> WidgetClassSelectionClearEventFieldCallback -> C_WidgetClassSelectionClearEventFieldCallback
type C_WidgetClassSelectionGetFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> Word32 -> IO ()
type WidgetClassSelectionGetFieldCallback = Widget -> SelectionData -> Word32 -> Word32 -> IO ()
dynamic_WidgetClassSelectionGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionGetFieldCallback -> a -> SelectionData -> Word32 -> Word32 -> m ()
genClosure_WidgetClassSelectionGetFieldCallback :: MonadIO m => WidgetClassSelectionGetFieldCallback -> m (GClosure C_WidgetClassSelectionGetFieldCallback)
mk_WidgetClassSelectionGetFieldCallback :: C_WidgetClassSelectionGetFieldCallback -> IO (FunPtr C_WidgetClassSelectionGetFieldCallback)
noWidgetClassSelectionGetFieldCallback :: Maybe WidgetClassSelectionGetFieldCallback
wrap_WidgetClassSelectionGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionGetFieldCallback)) -> WidgetClassSelectionGetFieldCallback -> C_WidgetClassSelectionGetFieldCallback
type C_WidgetClassSelectionNotifyEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt
type WidgetClassSelectionNotifyEventFieldCallback = Widget -> EventSelection -> IO Bool
dynamic_WidgetClassSelectionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionNotifyEventFieldCallback -> a -> EventSelection -> m Bool
genClosure_WidgetClassSelectionNotifyEventFieldCallback :: MonadIO m => WidgetClassSelectionNotifyEventFieldCallback -> m (GClosure C_WidgetClassSelectionNotifyEventFieldCallback)
mk_WidgetClassSelectionNotifyEventFieldCallback :: C_WidgetClassSelectionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)
noWidgetClassSelectionNotifyEventFieldCallback :: Maybe WidgetClassSelectionNotifyEventFieldCallback
wrap_WidgetClassSelectionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)) -> WidgetClassSelectionNotifyEventFieldCallback -> C_WidgetClassSelectionNotifyEventFieldCallback
type C_WidgetClassSelectionReceivedFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> IO ()
type WidgetClassSelectionReceivedFieldCallback = Widget -> SelectionData -> Word32 -> IO ()
dynamic_WidgetClassSelectionReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionReceivedFieldCallback -> a -> SelectionData -> Word32 -> m ()
genClosure_WidgetClassSelectionReceivedFieldCallback :: MonadIO m => WidgetClassSelectionReceivedFieldCallback -> m (GClosure C_WidgetClassSelectionReceivedFieldCallback)
mk_WidgetClassSelectionReceivedFieldCallback :: C_WidgetClassSelectionReceivedFieldCallback -> IO (FunPtr C_WidgetClassSelectionReceivedFieldCallback)
noWidgetClassSelectionReceivedFieldCallback :: Maybe WidgetClassSelectionReceivedFieldCallback
wrap_WidgetClassSelectionReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionReceivedFieldCallback)) -> WidgetClassSelectionReceivedFieldCallback -> C_WidgetClassSelectionReceivedFieldCallback
type C_WidgetClassSelectionRequestEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt
type WidgetClassSelectionRequestEventFieldCallback = Widget -> EventSelection -> IO Bool
dynamic_WidgetClassSelectionRequestEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionRequestEventFieldCallback -> a -> EventSelection -> m Bool
genClosure_WidgetClassSelectionRequestEventFieldCallback :: MonadIO m => WidgetClassSelectionRequestEventFieldCallback -> m (GClosure C_WidgetClassSelectionRequestEventFieldCallback)
mk_WidgetClassSelectionRequestEventFieldCallback :: C_WidgetClassSelectionRequestEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)
noWidgetClassSelectionRequestEventFieldCallback :: Maybe WidgetClassSelectionRequestEventFieldCallback
wrap_WidgetClassSelectionRequestEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)) -> WidgetClassSelectionRequestEventFieldCallback -> C_WidgetClassSelectionRequestEventFieldCallback
type C_WidgetClassShowAllFieldCallback = Ptr Widget -> IO ()
type WidgetClassShowAllFieldCallback = Widget -> IO ()
dynamic_WidgetClassShowAllFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowAllFieldCallback -> a -> m ()
genClosure_WidgetClassShowAllFieldCallback :: MonadIO m => WidgetClassShowAllFieldCallback -> m (GClosure C_WidgetClassShowAllFieldCallback)
mk_WidgetClassShowAllFieldCallback :: C_WidgetClassShowAllFieldCallback -> IO (FunPtr C_WidgetClassShowAllFieldCallback)
noWidgetClassShowAllFieldCallback :: Maybe WidgetClassShowAllFieldCallback
wrap_WidgetClassShowAllFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowAllFieldCallback)) -> WidgetClassShowAllFieldCallback -> C_WidgetClassShowAllFieldCallback
type C_WidgetClassShowFieldCallback = Ptr Widget -> IO ()
type WidgetClassShowFieldCallback = Widget -> IO ()
dynamic_WidgetClassShowFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
genClosure_WidgetClassShowFieldCallback :: MonadIO m => WidgetClassShowFieldCallback -> m (GClosure C_WidgetClassShowFieldCallback)
mk_WidgetClassShowFieldCallback :: C_WidgetClassShowFieldCallback -> IO (FunPtr C_WidgetClassShowFieldCallback)
noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback
wrap_WidgetClassShowFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowFieldCallback)) -> WidgetClassShowFieldCallback -> C_WidgetClassShowFieldCallback
type C_WidgetClassShowHelpFieldCallback = Ptr Widget -> CUInt -> IO CInt
type WidgetClassShowHelpFieldCallback = Widget -> WidgetHelpType -> IO Bool
dynamic_WidgetClassShowHelpFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowHelpFieldCallback -> a -> WidgetHelpType -> m Bool
genClosure_WidgetClassShowHelpFieldCallback :: MonadIO m => WidgetClassShowHelpFieldCallback -> m (GClosure C_WidgetClassShowHelpFieldCallback)
mk_WidgetClassShowHelpFieldCallback :: C_WidgetClassShowHelpFieldCallback -> IO (FunPtr C_WidgetClassShowHelpFieldCallback)
noWidgetClassShowHelpFieldCallback :: Maybe WidgetClassShowHelpFieldCallback
wrap_WidgetClassShowHelpFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowHelpFieldCallback)) -> WidgetClassShowHelpFieldCallback -> C_WidgetClassShowHelpFieldCallback
type C_WidgetClassSizeAllocateFieldCallback = Ptr Widget -> Ptr Rectangle -> IO ()
type WidgetClassSizeAllocateFieldCallback = Widget -> Rectangle -> IO ()
dynamic_WidgetClassSizeAllocateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSizeAllocateFieldCallback -> a -> Rectangle -> m ()
genClosure_WidgetClassSizeAllocateFieldCallback :: MonadIO m => WidgetClassSizeAllocateFieldCallback -> m (GClosure C_WidgetClassSizeAllocateFieldCallback)
mk_WidgetClassSizeAllocateFieldCallback :: C_WidgetClassSizeAllocateFieldCallback -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)
noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback
wrap_WidgetClassSizeAllocateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)) -> WidgetClassSizeAllocateFieldCallback -> C_WidgetClassSizeAllocateFieldCallback
type C_WidgetClassStateChangedFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassStateChangedFieldCallback = Widget -> StateType -> IO ()
dynamic_WidgetClassStateChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateChangedFieldCallback -> a -> StateType -> m ()
genClosure_WidgetClassStateChangedFieldCallback :: MonadIO m => WidgetClassStateChangedFieldCallback -> m (GClosure C_WidgetClassStateChangedFieldCallback)
mk_WidgetClassStateChangedFieldCallback :: C_WidgetClassStateChangedFieldCallback -> IO (FunPtr C_WidgetClassStateChangedFieldCallback)
noWidgetClassStateChangedFieldCallback :: Maybe WidgetClassStateChangedFieldCallback
wrap_WidgetClassStateChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)) -> WidgetClassStateChangedFieldCallback -> C_WidgetClassStateChangedFieldCallback
type C_WidgetClassStateFlagsChangedFieldCallback = Ptr Widget -> CUInt -> IO ()
type WidgetClassStateFlagsChangedFieldCallback = Widget -> [StateFlags] -> IO ()
dynamic_WidgetClassStateFlagsChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> a -> [StateFlags] -> m ()
genClosure_WidgetClassStateFlagsChangedFieldCallback :: MonadIO m => WidgetClassStateFlagsChangedFieldCallback -> m (GClosure C_WidgetClassStateFlagsChangedFieldCallback)
mk_WidgetClassStateFlagsChangedFieldCallback :: C_WidgetClassStateFlagsChangedFieldCallback -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback
wrap_WidgetClassStateFlagsChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)) -> WidgetClassStateFlagsChangedFieldCallback -> C_WidgetClassStateFlagsChangedFieldCallback
type C_WidgetClassStyleSetFieldCallback = Ptr Widget -> Ptr Style -> IO ()
type WidgetClassStyleSetFieldCallback = Widget -> Style -> IO ()
dynamic_WidgetClassStyleSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsStyle b) => FunPtr C_WidgetClassStyleSetFieldCallback -> a -> b -> m ()
genClosure_WidgetClassStyleSetFieldCallback :: MonadIO m => WidgetClassStyleSetFieldCallback -> m (GClosure C_WidgetClassStyleSetFieldCallback)
mk_WidgetClassStyleSetFieldCallback :: C_WidgetClassStyleSetFieldCallback -> IO (FunPtr C_WidgetClassStyleSetFieldCallback)
noWidgetClassStyleSetFieldCallback :: Maybe WidgetClassStyleSetFieldCallback
wrap_WidgetClassStyleSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleSetFieldCallback)) -> WidgetClassStyleSetFieldCallback -> C_WidgetClassStyleSetFieldCallback
type C_WidgetClassStyleUpdatedFieldCallback = Ptr Widget -> IO ()
type WidgetClassStyleUpdatedFieldCallback = Widget -> IO ()
dynamic_WidgetClassStyleUpdatedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStyleUpdatedFieldCallback -> a -> m ()
genClosure_WidgetClassStyleUpdatedFieldCallback :: MonadIO m => WidgetClassStyleUpdatedFieldCallback -> m (GClosure C_WidgetClassStyleUpdatedFieldCallback)
mk_WidgetClassStyleUpdatedFieldCallback :: C_WidgetClassStyleUpdatedFieldCallback -> IO (FunPtr C_WidgetClassStyleUpdatedFieldCallback)
noWidgetClassStyleUpdatedFieldCallback :: Maybe WidgetClassStyleUpdatedFieldCallback
wrap_WidgetClassStyleUpdatedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleUpdatedFieldCallback)) -> WidgetClassStyleUpdatedFieldCallback -> C_WidgetClassStyleUpdatedFieldCallback
type C_WidgetClassTouchEventFieldCallback = Ptr Widget -> Ptr EventTouch -> IO CInt
type WidgetClassTouchEventFieldCallback = Widget -> EventTouch -> IO Bool
dynamic_WidgetClassTouchEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassTouchEventFieldCallback -> a -> EventTouch -> m Bool
genClosure_WidgetClassTouchEventFieldCallback :: MonadIO m => WidgetClassTouchEventFieldCallback -> m (GClosure C_WidgetClassTouchEventFieldCallback)
mk_WidgetClassTouchEventFieldCallback :: C_WidgetClassTouchEventFieldCallback -> IO (FunPtr C_WidgetClassTouchEventFieldCallback)
noWidgetClassTouchEventFieldCallback :: Maybe WidgetClassTouchEventFieldCallback
wrap_WidgetClassTouchEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassTouchEventFieldCallback)) -> WidgetClassTouchEventFieldCallback -> C_WidgetClassTouchEventFieldCallback
type C_WidgetClassUnmapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt
type WidgetClassUnmapEventFieldCallback = Widget -> EventAny -> IO Bool
dynamic_WidgetClassUnmapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapEventFieldCallback -> a -> EventAny -> m Bool
genClosure_WidgetClassUnmapEventFieldCallback :: MonadIO m => WidgetClassUnmapEventFieldCallback -> m (GClosure C_WidgetClassUnmapEventFieldCallback)
mk_WidgetClassUnmapEventFieldCallback :: C_WidgetClassUnmapEventFieldCallback -> IO (FunPtr C_WidgetClassUnmapEventFieldCallback)
noWidgetClassUnmapEventFieldCallback :: Maybe WidgetClassUnmapEventFieldCallback
wrap_WidgetClassUnmapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapEventFieldCallback)) -> WidgetClassUnmapEventFieldCallback -> C_WidgetClassUnmapEventFieldCallback
type C_WidgetClassUnmapFieldCallback = Ptr Widget -> IO ()
type WidgetClassUnmapFieldCallback = Widget -> IO ()
dynamic_WidgetClassUnmapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapFieldCallback -> a -> m ()
genClosure_WidgetClassUnmapFieldCallback :: MonadIO m => WidgetClassUnmapFieldCallback -> m (GClosure C_WidgetClassUnmapFieldCallback)
mk_WidgetClassUnmapFieldCallback :: C_WidgetClassUnmapFieldCallback -> IO (FunPtr C_WidgetClassUnmapFieldCallback)
noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback
wrap_WidgetClassUnmapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapFieldCallback)) -> WidgetClassUnmapFieldCallback -> C_WidgetClassUnmapFieldCallback
type C_WidgetClassUnrealizeFieldCallback = Ptr Widget -> IO ()
type WidgetClassUnrealizeFieldCallback = Widget -> IO ()
dynamic_WidgetClassUnrealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnrealizeFieldCallback -> a -> m ()
genClosure_WidgetClassUnrealizeFieldCallback :: MonadIO m => WidgetClassUnrealizeFieldCallback -> m (GClosure C_WidgetClassUnrealizeFieldCallback)
mk_WidgetClassUnrealizeFieldCallback :: C_WidgetClassUnrealizeFieldCallback -> IO (FunPtr C_WidgetClassUnrealizeFieldCallback)
noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback
wrap_WidgetClassUnrealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrealizeFieldCallback)) -> WidgetClassUnrealizeFieldCallback -> C_WidgetClassUnrealizeFieldCallback
type C_WidgetClassVisibilityNotifyEventFieldCallback = Ptr Widget -> Ptr EventVisibility -> IO CInt
type WidgetClassVisibilityNotifyEventFieldCallback = Widget -> EventVisibility -> IO Bool
dynamic_WidgetClassVisibilityNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> a -> EventVisibility -> m Bool
genClosure_WidgetClassVisibilityNotifyEventFieldCallback :: MonadIO m => WidgetClassVisibilityNotifyEventFieldCallback -> m (GClosure C_WidgetClassVisibilityNotifyEventFieldCallback)
mk_WidgetClassVisibilityNotifyEventFieldCallback :: C_WidgetClassVisibilityNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)
noWidgetClassVisibilityNotifyEventFieldCallback :: Maybe WidgetClassVisibilityNotifyEventFieldCallback
wrap_WidgetClassVisibilityNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)) -> WidgetClassVisibilityNotifyEventFieldCallback -> C_WidgetClassVisibilityNotifyEventFieldCallback
type C_WidgetClassWindowStateEventFieldCallback = Ptr Widget -> Ptr EventWindowState -> IO CInt
type WidgetClassWindowStateEventFieldCallback = Widget -> EventWindowState -> IO Bool
dynamic_WidgetClassWindowStateEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassWindowStateEventFieldCallback -> a -> EventWindowState -> m Bool
genClosure_WidgetClassWindowStateEventFieldCallback :: MonadIO m => WidgetClassWindowStateEventFieldCallback -> m (GClosure C_WidgetClassWindowStateEventFieldCallback)
mk_WidgetClassWindowStateEventFieldCallback :: C_WidgetClassWindowStateEventFieldCallback -> IO (FunPtr C_WidgetClassWindowStateEventFieldCallback)
noWidgetClassWindowStateEventFieldCallback :: Maybe WidgetClassWindowStateEventFieldCallback
wrap_WidgetClassWindowStateEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassWindowStateEventFieldCallback)) -> WidgetClassWindowStateEventFieldCallback -> C_WidgetClassWindowStateEventFieldCallback

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 :: MonadIO m => AccelGroupActivate -> m (GClosure C_AccelGroupActivate) Source #

Wrap the callback into a GClosure.

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

No description available in the introspection data.

Since: 2.2

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

No description available in the introspection data.

Since: 2.2

type C_AccelGroupFindFunc = Ptr AccelKey -> Ptr (GClosure ()) -> 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 -> GClosure a -> Ptr () -> m Bool Source #

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

genClosure_AccelGroupFindFunc :: MonadIO m => AccelGroupFindFunc -> m (GClosure C_AccelGroupFindFunc) Source #

Wrap the callback into a GClosure.

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 :: MonadIO m => AccelMapForeach -> m (GClosure C_AccelMapForeach) Source #

Wrap the callback into a GClosure.

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 :: MonadIO m => AssistantPageFunc -> m (GClosure C_AssistantPageFunc) Source #

Wrap the callback into a GClosure.

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

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

noAssistantPageFunc :: Maybe AssistantPageFunc Source #

A convenience synonym for Nothing :: Maybe AssistantPageFunc.

noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe AssistantPageFunc_WithClosures.

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

Wrap a AssistantPageFunc into a C_AssistantPageFunc.

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 :: MonadIO m => BuilderConnectFunc -> m (GClosure C_BuilderConnectFunc) Source #

Wrap the callback into a GClosure.

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 :: MonadIO m => CalendarDetailFunc -> m (GClosure C_CalendarDetailFunc) Source #

Wrap the callback into a GClosure.

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 :: MonadIO m => Callback -> m (GClosure C_Callback) Source #

Wrap the callback into a GClosure.

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 :: MonadIO m => CellAllocCallback -> m (GClosure C_CellAllocCallback) Source #

Wrap the callback into a GClosure.

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

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

noCellAllocCallback :: Maybe CellAllocCallback Source #

A convenience synonym for Nothing :: Maybe CellAllocCallback.

noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe CellAllocCallback_WithClosures.

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

Wrap a CellAllocCallback into a C_CellAllocCallback.

CellCallback

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

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

type CellCallback Source #

Arguments

= CellRenderer	`renderer`: the cell renderer to operate on
-> IO Bool	Returns: `True` to stop iterating over cells.

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

type CellCallback_WithClosures Source #

Arguments

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

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

drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CellCallback Source #

Arguments

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

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

genClosure_CellCallback :: MonadIO m => CellCallback -> m (GClosure C_CellCallback) Source #

Wrap the callback into a GClosure.

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

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

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 :: MonadIO m => CellLayoutDataFunc -> m (GClosure C_CellLayoutDataFunc) Source #

Wrap the callback into a GClosure.

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

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

noCellLayoutDataFunc :: Maybe CellLayoutDataFunc Source #

A convenience synonym for Nothing :: Maybe CellLayoutDataFunc.

noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe CellLayoutDataFunc_WithClosures.

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

Wrap a CellLayoutDataFunc into a C_CellLayoutDataFunc.

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 :: MonadIO m => ClipboardClearFunc -> m (GClosure C_ClipboardClearFunc) Source #

Wrap the callback into a GClosure.

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 :: MonadIO m => ClipboardGetFunc -> m (GClosure C_ClipboardGetFunc) Source #

Wrap the callback into a GClosure.

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`
-> Maybe 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`
-> Maybe 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`
-> Maybe 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 :: MonadIO m => ClipboardImageReceivedFunc -> m (GClosure C_ClipboardImageReceivedFunc) Source #

Wrap the callback into a GClosure.

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 :: MonadIO m => ClipboardReceivedFunc -> m (GClosure C_ClipboardReceivedFunc) Source #

Wrap the callback into a GClosure.

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