gi-gtk3-3.0.44: Gtk 3.x bindings

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

GI.Gtk.Callbacks

Contents

- Signals
  - AccelGroupActivate
  - AccelGroupFindFunc
  - AccelMapForeach
  - ActionableInterfaceGetActionNameFieldCallback
  - ActionableInterfaceGetActionTargetValueFieldCallback
  - ActionableInterfaceSetActionNameFieldCallback
  - ActionableInterfaceSetActionTargetValueFieldCallback
  - AssistantPageFunc
  - BuilderConnectFunc
  - CalendarDetailFunc
  - Callback
  - CellAllocCallback
  - CellCallback
  - CellLayoutDataFunc
  - ClipboardClearFunc
  - ClipboardGetFunc
  - ClipboardImageReceivedFunc
  - ClipboardReceivedFunc
  - ClipboardRichTextReceivedFunc
  - ClipboardTargetsReceivedFunc
  - ClipboardTextReceivedFunc
  - ClipboardURIReceivedFunc
  - ColorSelectionChangePaletteFunc
  - ColorSelectionChangePaletteWithScreenFunc
  - ContainerClassAddFieldCallback
  - ContainerClassCheckResizeFieldCallback
  - ContainerClassChildTypeFieldCallback
  - ContainerClassCompositeNameFieldCallback
  - ContainerClassForallFieldCallback
  - ContainerClassGetChildPropertyFieldCallback
  - ContainerClassGetPathForChildFieldCallback
  - ContainerClassRemoveFieldCallback
  - ContainerClassSetChildPropertyFieldCallback
  - ContainerClassSetFocusChildFieldCallback
  - EntryCompletionMatchFunc
  - FileFilterFunc
  - FlowBoxCreateWidgetFunc
  - FlowBoxFilterFunc
  - FlowBoxForeachFunc
  - FlowBoxSortFunc
  - FontFilterFunc
  - IconViewForeachFunc
  - KeySnoopFunc
  - ListBoxCreateWidgetFunc
  - ListBoxFilterFunc
  - ListBoxForeachFunc
  - ListBoxSortFunc
  - ListBoxUpdateHeaderFunc
  - MenuDetachFunc
  - MenuPositionFunc
  - ModuleDisplayInitFunc
  - ModuleInitFunc
  - PageSetupDoneFunc
  - PrintSettingsFunc
  - RcPropertyParser
  - RecentFilterFunc
  - RecentSortFunc
  - StylePropertyParser
  - TextBufferDeserializeFunc
  - TextBufferSerializeFunc
  - TextCharPredicate
  - TextTagTableForeach
  - TickCallback
  - TranslateFunc
  - TreeCellDataFunc
  - TreeDestroyCountFunc
  - TreeIterCompareFunc
  - TreeModelFilterModifyFunc
  - TreeModelFilterVisibleFunc
  - TreeModelForeachFunc
  - TreeSelectionForeachFunc
  - TreeSelectionFunc
  - TreeViewColumnDropFunc
  - TreeViewMappingFunc
  - TreeViewRowSeparatorFunc
  - TreeViewSearchEqualFunc
  - TreeViewSearchPositionFunc
  - WidgetClassAdjustBaselineAllocationFieldCallback
  - WidgetClassAdjustBaselineRequestFieldCallback
  - WidgetClassAdjustSizeAllocationFieldCallback
  - WidgetClassAdjustSizeRequestFieldCallback
  - WidgetClassButtonPressEventFieldCallback
  - WidgetClassButtonReleaseEventFieldCallback
  - WidgetClassCanActivateAccelFieldCallback
  - WidgetClassChildNotifyFieldCallback
  - WidgetClassCompositedChangedFieldCallback
  - WidgetClassComputeExpandFieldCallback
  - WidgetClassConfigureEventFieldCallback
  - WidgetClassDamageEventFieldCallback
  - WidgetClassDeleteEventFieldCallback
  - WidgetClassDestroyEventFieldCallback
  - WidgetClassDestroyFieldCallback
  - WidgetClassDirectionChangedFieldCallback
  - WidgetClassDispatchChildPropertiesChangedFieldCallback
  - WidgetClassDragBeginFieldCallback
  - WidgetClassDragDataDeleteFieldCallback
  - WidgetClassDragDataGetFieldCallback
  - WidgetClassDragDataReceivedFieldCallback
  - WidgetClassDragDropFieldCallback
  - WidgetClassDragEndFieldCallback
  - WidgetClassDragFailedFieldCallback
  - WidgetClassDragLeaveFieldCallback
  - WidgetClassDragMotionFieldCallback
  - WidgetClassDrawFieldCallback
  - WidgetClassEnterNotifyEventFieldCallback
  - WidgetClassEventFieldCallback
  - WidgetClassFocusFieldCallback
  - WidgetClassFocusInEventFieldCallback
  - WidgetClassFocusOutEventFieldCallback
  - WidgetClassGetAccessibleFieldCallback
  - WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
  - WidgetClassGetPreferredHeightFieldCallback
  - WidgetClassGetPreferredHeightForWidthFieldCallback
  - WidgetClassGetPreferredWidthFieldCallback
  - WidgetClassGetPreferredWidthForHeightFieldCallback
  - WidgetClassGetRequestModeFieldCallback
  - WidgetClassGrabBrokenEventFieldCallback
  - WidgetClassGrabFocusFieldCallback
  - WidgetClassGrabNotifyFieldCallback
  - WidgetClassHideFieldCallback
  - WidgetClassHierarchyChangedFieldCallback
  - WidgetClassKeyPressEventFieldCallback
  - WidgetClassKeyReleaseEventFieldCallback
  - WidgetClassKeynavFailedFieldCallback
  - WidgetClassLeaveNotifyEventFieldCallback
  - WidgetClassMapEventFieldCallback
  - WidgetClassMapFieldCallback
  - WidgetClassMnemonicActivateFieldCallback
  - WidgetClassMotionNotifyEventFieldCallback
  - WidgetClassMoveFocusFieldCallback
  - WidgetClassParentSetFieldCallback
  - WidgetClassPopupMenuFieldCallback
  - WidgetClassPropertyNotifyEventFieldCallback
  - WidgetClassProximityInEventFieldCallback
  - WidgetClassProximityOutEventFieldCallback
  - WidgetClassQueryTooltipFieldCallback
  - WidgetClassQueueDrawRegionFieldCallback
  - WidgetClassRealizeFieldCallback
  - WidgetClassScreenChangedFieldCallback
  - WidgetClassScrollEventFieldCallback
  - WidgetClassSelectionClearEventFieldCallback
  - WidgetClassSelectionGetFieldCallback
  - WidgetClassSelectionNotifyEventFieldCallback
  - WidgetClassSelectionReceivedFieldCallback
  - WidgetClassSelectionRequestEventFieldCallback
  - WidgetClassShowAllFieldCallback
  - WidgetClassShowFieldCallback
  - WidgetClassShowHelpFieldCallback
  - WidgetClassSizeAllocateFieldCallback
  - WidgetClassStateChangedFieldCallback
  - WidgetClassStateFlagsChangedFieldCallback
  - WidgetClassStyleSetFieldCallback
  - WidgetClassStyleUpdatedFieldCallback
  - WidgetClassTouchEventFieldCallback
  - WidgetClassUnmapEventFieldCallback
  - WidgetClassUnmapFieldCallback
  - WidgetClassUnrealizeFieldCallback
  - WidgetClassVisibilityNotifyEventFieldCallback
  - WidgetClassWindowStateEventFieldCallback

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 ActionableInterfaceGetActionNameFieldCallback = Actionable -> IO (Maybe Text)
- type C_ActionableInterfaceGetActionNameFieldCallback = Ptr Actionable -> IO CString
- dynamic_ActionableInterfaceGetActionNameFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceGetActionNameFieldCallback -> a -> m (Maybe Text)
- genClosure_ActionableInterfaceGetActionNameFieldCallback :: MonadIO m => ActionableInterfaceGetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceGetActionNameFieldCallback)
- mk_ActionableInterfaceGetActionNameFieldCallback :: C_ActionableInterfaceGetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionNameFieldCallback)
- noActionableInterfaceGetActionNameFieldCallback :: Maybe ActionableInterfaceGetActionNameFieldCallback
- wrap_ActionableInterfaceGetActionNameFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceGetActionNameFieldCallback)) -> ActionableInterfaceGetActionNameFieldCallback -> C_ActionableInterfaceGetActionNameFieldCallback
- type ActionableInterfaceGetActionTargetValueFieldCallback = Actionable -> IO GVariant
- type C_ActionableInterfaceGetActionTargetValueFieldCallback = Ptr Actionable -> IO (Ptr GVariant)
- dynamic_ActionableInterfaceGetActionTargetValueFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback -> a -> m GVariant
- genClosure_ActionableInterfaceGetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceGetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceGetActionTargetValueFieldCallback)
- mk_ActionableInterfaceGetActionTargetValueFieldCallback :: C_ActionableInterfaceGetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback)
- noActionableInterfaceGetActionTargetValueFieldCallback :: Maybe ActionableInterfaceGetActionTargetValueFieldCallback
- wrap_ActionableInterfaceGetActionTargetValueFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback)) -> ActionableInterfaceGetActionTargetValueFieldCallback -> C_ActionableInterfaceGetActionTargetValueFieldCallback
- type ActionableInterfaceSetActionNameFieldCallback = Actionable -> Maybe Text -> IO ()
- type C_ActionableInterfaceSetActionNameFieldCallback = Ptr Actionable -> CString -> IO ()
- dynamic_ActionableInterfaceSetActionNameFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceSetActionNameFieldCallback -> a -> Maybe Text -> m ()
- genClosure_ActionableInterfaceSetActionNameFieldCallback :: MonadIO m => ActionableInterfaceSetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceSetActionNameFieldCallback)
- mk_ActionableInterfaceSetActionNameFieldCallback :: C_ActionableInterfaceSetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionNameFieldCallback)
- noActionableInterfaceSetActionNameFieldCallback :: Maybe ActionableInterfaceSetActionNameFieldCallback
- wrap_ActionableInterfaceSetActionNameFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceSetActionNameFieldCallback)) -> ActionableInterfaceSetActionNameFieldCallback -> C_ActionableInterfaceSetActionNameFieldCallback
- type ActionableInterfaceSetActionTargetValueFieldCallback = Actionable -> Maybe GVariant -> IO ()
- type C_ActionableInterfaceSetActionTargetValueFieldCallback = Ptr Actionable -> Ptr GVariant -> IO ()
- dynamic_ActionableInterfaceSetActionTargetValueFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback -> a -> Maybe GVariant -> m ()
- genClosure_ActionableInterfaceSetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceSetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceSetActionTargetValueFieldCallback)
- mk_ActionableInterfaceSetActionTargetValueFieldCallback :: C_ActionableInterfaceSetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback)
- noActionableInterfaceSetActionTargetValueFieldCallback :: Maybe ActionableInterfaceSetActionTargetValueFieldCallback
- wrap_ActionableInterfaceSetActionTargetValueFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback)) -> ActionableInterfaceSetActionTargetValueFieldCallback -> C_ActionableInterfaceSetActionTargetValueFieldCallback
- 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 -> CSize -> Ptr () -> IO ()
- type ClipboardRichTextReceivedFunc = Clipboard -> Atom -> Maybe Text -> CSize -> IO ()
- type ClipboardRichTextReceivedFunc_WithClosures = Clipboard -> Atom -> Maybe Text -> CSize -> Ptr () -> IO ()
- drop_closures_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> ClipboardRichTextReceivedFunc_WithClosures
- dynamic_ClipboardRichTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardRichTextReceivedFunc -> a -> Atom -> Maybe Text -> CSize -> 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 -> CSize -> 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 -> Ptr CSize -> Ptr () -> IO (Ptr Word8)
- type TextBufferSerializeFunc = TextBuffer -> TextBuffer -> TextIter -> TextIter -> IO (Maybe ByteString)
- type TextBufferSerializeFunc_WithClosures = TextBuffer -> TextBuffer -> TextIter -> TextIter -> Ptr () -> IO (Maybe ByteString)
- drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures
- dynamic_TextBufferSerializeFunc :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => FunPtr C_TextBufferSerializeFunc -> a -> b -> TextIter -> TextIter -> Ptr () -> m (Maybe ByteString)
- 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_TreeModelFilterModifyFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr GValue -> Int32 -> Ptr () -> IO ()
- type TreeModelFilterModifyFunc = TreeModel -> TreeIter -> Int32 -> IO GValue
- type TreeModelFilterModifyFunc_WithClosures = TreeModel -> TreeIter -> Int32 -> Ptr () -> IO GValue
- drop_closures_TreeModelFilterModifyFunc :: TreeModelFilterModifyFunc -> TreeModelFilterModifyFunc_WithClosures
- dynamic_TreeModelFilterModifyFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterModifyFunc -> a -> TreeIter -> Int32 -> Ptr () -> m GValue
- genClosure_TreeModelFilterModifyFunc :: MonadIO m => TreeModelFilterModifyFunc -> m (GClosure C_TreeModelFilterModifyFunc)
- mk_TreeModelFilterModifyFunc :: C_TreeModelFilterModifyFunc -> IO (FunPtr C_TreeModelFilterModifyFunc)
- noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc
- noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures
- wrap_TreeModelFilterModifyFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterModifyFunc)) -> TreeModelFilterModifyFunc_WithClosures -> C_TreeModelFilterModifyFunc
- type C_TreeModelFilterVisibleFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt
- type TreeModelFilterVisibleFunc = TreeModel -> TreeIter -> IO Bool
- type TreeModelFilterVisibleFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool
- drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures
- dynamic_TreeModelFilterVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterVisibleFunc -> a -> TreeIter -> Ptr () -> m Bool
- genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc)
- mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)
- noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc
- noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures
- wrap_TreeModelFilterVisibleFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc)) -> TreeModelFilterVisibleFunc_WithClosures -> C_TreeModelFilterVisibleFunc
- type C_TreeModelForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt
- type TreeModelForeachFunc = TreeModel -> TreePath -> TreeIter -> IO Bool
- type TreeModelForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO Bool
- drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures
- dynamic_TreeModelForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m Bool
- genClosure_TreeModelForeachFunc :: MonadIO m => TreeModelForeachFunc -> m (GClosure C_TreeModelForeachFunc)
- mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)
- noTreeModelForeachFunc :: Maybe TreeModelForeachFunc
- noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures
- wrap_TreeModelForeachFunc :: Maybe (Ptr (FunPtr C_TreeModelForeachFunc)) -> TreeModelForeachFunc_WithClosures -> C_TreeModelForeachFunc
- type C_TreeSelectionForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()
- type TreeSelectionForeachFunc = TreeModel -> TreePath -> TreeIter -> IO ()
- type TreeSelectionForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO ()
- drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures
- dynamic_TreeSelectionForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeSelectionForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m ()
- genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc)
- mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)
- noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc
- noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures
- wrap_TreeSelectionForeachFunc :: Maybe (Ptr (FunPtr C_TreeSelectionForeachFunc)) -> TreeSelectionForeachFunc_WithClosures -> C_TreeSelectionForeachFunc
- type C_TreeSelectionFunc = Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt
- type TreeSelectionFunc = TreeSelection -> TreeModel -> TreePath -> Bool -> IO Bool
- type TreeSelectionFunc_WithClosures = TreeSelection -> TreeModel -> TreePath -> Bool -> Ptr () -> IO Bool
- drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures
- dynamic_TreeSelectionFunc :: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b) => FunPtr C_TreeSelectionFunc -> a -> b -> TreePath -> Bool -> Ptr () -> m Bool
- genClosure_TreeSelectionFunc :: MonadIO m => TreeSelectionFunc -> m (GClosure C_TreeSelectionFunc)
- mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)
- noTreeSelectionFunc :: Maybe TreeSelectionFunc
- noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures
- wrap_TreeSelectionFunc :: Maybe (Ptr (FunPtr C_TreeSelectionFunc)) -> TreeSelectionFunc_WithClosures -> C_TreeSelectionFunc
- type C_TreeViewColumnDropFunc = Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt
- type TreeViewColumnDropFunc = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> IO Bool
- type TreeViewColumnDropFunc_WithClosures = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> Ptr () -> IO Bool
- drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures
- dynamic_TreeViewColumnDropFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d) => FunPtr C_TreeViewColumnDropFunc -> a -> b -> c -> d -> Ptr () -> m Bool
- genClosure_TreeViewColumnDropFunc :: MonadIO m => TreeViewColumnDropFunc -> m (GClosure C_TreeViewColumnDropFunc)
- mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)
- noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc
- noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures
- wrap_TreeViewColumnDropFunc :: Maybe (Ptr (FunPtr C_TreeViewColumnDropFunc)) -> TreeViewColumnDropFunc_WithClosures -> C_TreeViewColumnDropFunc
- type C_TreeViewMappingFunc = Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()
- type TreeViewMappingFunc = TreeView -> TreePath -> IO ()
- type TreeViewMappingFunc_WithClosures = TreeView -> TreePath -> Ptr () -> IO ()
- drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures
- dynamic_TreeViewMappingFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeViewMappingFunc -> a -> TreePath -> Ptr () -> m ()
- genClosure_TreeViewMappingFunc :: MonadIO m => TreeViewMappingFunc -> m (GClosure C_TreeViewMappingFunc)
- mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)
- noTreeViewMappingFunc :: Maybe TreeViewMappingFunc
- noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures
- wrap_TreeViewMappingFunc :: Maybe (Ptr (FunPtr C_TreeViewMappingFunc)) -> TreeViewMappingFunc_WithClosures -> C_TreeViewMappingFunc
- type C_TreeViewRowSeparatorFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt
- type TreeViewRowSeparatorFunc = TreeModel -> TreeIter -> IO Bool
- type TreeViewRowSeparatorFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool
- drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures
- dynamic_TreeViewRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewRowSeparatorFunc -> a -> TreeIter -> Ptr () -> m Bool
- genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc)
- mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)
- noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc
- noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures
- wrap_TreeViewRowSeparatorFunc :: Maybe (Ptr (FunPtr C_TreeViewRowSeparatorFunc)) -> TreeViewRowSeparatorFunc_WithClosures -> C_TreeViewRowSeparatorFunc
- type C_TreeViewSearchEqualFunc = Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt
- type TreeViewSearchEqualFunc = TreeModel -> Int32 -> Text -> TreeIter -> IO Bool
- type TreeViewSearchEqualFunc_WithClosures = TreeModel -> Int32 -> Text -> TreeIter -> Ptr () -> IO Bool
- drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures
- dynamic_TreeViewSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewSearchEqualFunc -> a -> Int32 -> Text -> TreeIter -> Ptr () -> m Bool
- genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc)
- mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)
- noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc
- noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures
- wrap_TreeViewSearchEqualFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchEqualFunc)) -> TreeViewSearchEqualFunc_WithClosures -> C_TreeViewSearchEqualFunc
- type C_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`.

## ActionableInterfaceGetActionNameFieldCallback

type ActionableInterfaceGetActionNameFieldCallback Source #

Arguments

= Actionable | `actionable`: a `Actionable` widget
-> IO (Maybe Text) | Returns: the action name, or `Nothing` if none is set

No description available in the introspection data.

type C_ActionableInterfaceGetActionNameFieldCallback = Ptr Actionable -> IO CString Source #

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

dynamic_ActionableInterfaceGetActionNameFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsActionable a) |
=> FunPtr C_ActionableInterfaceGetActionNameFieldCallback |
-> a | `actionable`: a `Actionable` widget
-> m (Maybe Text) | Returns: the action name, or `Nothing` if none is set

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

genClosure_ActionableInterfaceGetActionNameFieldCallback :: MonadIO m => ActionableInterfaceGetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceGetActionNameFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ActionableInterfaceGetActionNameFieldCallback :: C_ActionableInterfaceGetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionNameFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ActionableInterfaceGetActionNameFieldCallback`.

noActionableInterfaceGetActionNameFieldCallback :: Maybe ActionableInterfaceGetActionNameFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ActionableInterfaceGetActionNameFieldCallback``.

wrap_ActionableInterfaceGetActionNameFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceGetActionNameFieldCallback)) -> ActionableInterfaceGetActionNameFieldCallback -> C_ActionableInterfaceGetActionNameFieldCallback Source #

Wrap a `ActionableInterfaceGetActionNameFieldCallback` into a `C_ActionableInterfaceGetActionNameFieldCallback`.

## ActionableInterfaceGetActionTargetValueFieldCallback

type ActionableInterfaceGetActionTargetValueFieldCallback Source #

Arguments

= Actionable | `actionable`: a `Actionable` widget
-> IO GVariant | Returns: the current target value

No description available in the introspection data.

type C_ActionableInterfaceGetActionTargetValueFieldCallback = Ptr Actionable -> IO (Ptr GVariant) Source #

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

dynamic_ActionableInterfaceGetActionTargetValueFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsActionable a) |
=> FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback |
-> a | `actionable`: a `Actionable` widget
-> m GVariant | Returns: the current target value

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

genClosure_ActionableInterfaceGetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceGetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceGetActionTargetValueFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ActionableInterfaceGetActionTargetValueFieldCallback :: C_ActionableInterfaceGetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ActionableInterfaceGetActionTargetValueFieldCallback`.

noActionableInterfaceGetActionTargetValueFieldCallback :: Maybe ActionableInterfaceGetActionTargetValueFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ActionableInterfaceGetActionTargetValueFieldCallback``.

wrap_ActionableInterfaceGetActionTargetValueFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback)) -> ActionableInterfaceGetActionTargetValueFieldCallback -> C_ActionableInterfaceGetActionTargetValueFieldCallback Source #

Wrap a `ActionableInterfaceGetActionTargetValueFieldCallback` into a `C_ActionableInterfaceGetActionTargetValueFieldCallback`.

## ActionableInterfaceSetActionNameFieldCallback

type ActionableInterfaceSetActionNameFieldCallback Source #

Arguments

= Actionable | `actionable`: a `Actionable` widget
-> Maybe Text | `actionName`: an action name, or `Nothing`
-> IO () |

No description available in the introspection data.

type C_ActionableInterfaceSetActionNameFieldCallback = Ptr Actionable -> CString -> IO () Source #

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

dynamic_ActionableInterfaceSetActionNameFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsActionable a) |
=> FunPtr C_ActionableInterfaceSetActionNameFieldCallback |
-> a | `actionable`: a `Actionable` widget
-> Maybe Text | `actionName`: an action name, or `Nothing`
-> m () |

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

genClosure_ActionableInterfaceSetActionNameFieldCallback :: MonadIO m => ActionableInterfaceSetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceSetActionNameFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ActionableInterfaceSetActionNameFieldCallback :: C_ActionableInterfaceSetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionNameFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ActionableInterfaceSetActionNameFieldCallback`.

noActionableInterfaceSetActionNameFieldCallback :: Maybe ActionableInterfaceSetActionNameFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ActionableInterfaceSetActionNameFieldCallback``.

wrap_ActionableInterfaceSetActionNameFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceSetActionNameFieldCallback)) -> ActionableInterfaceSetActionNameFieldCallback -> C_ActionableInterfaceSetActionNameFieldCallback Source #

Wrap a `ActionableInterfaceSetActionNameFieldCallback` into a `C_ActionableInterfaceSetActionNameFieldCallback`.

## ActionableInterfaceSetActionTargetValueFieldCallback

type ActionableInterfaceSetActionTargetValueFieldCallback Source #

Arguments

= Actionable | `actionable`: a `Actionable` widget
-> Maybe GVariant | `targetValue`: a `GVariant` to set as the target value, or `Nothing`
-> IO () |

No description available in the introspection data.

type C_ActionableInterfaceSetActionTargetValueFieldCallback = Ptr Actionable -> Ptr GVariant -> IO () Source #

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

dynamic_ActionableInterfaceSetActionTargetValueFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsActionable a) |
=> FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback |
-> a | `actionable`: a `Actionable` widget
-> Maybe GVariant | `targetValue`: a `GVariant` to set as the target value, or `Nothing`
-> m () |

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

genClosure_ActionableInterfaceSetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceSetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceSetActionTargetValueFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ActionableInterfaceSetActionTargetValueFieldCallback :: C_ActionableInterfaceSetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ActionableInterfaceSetActionTargetValueFieldCallback`.

noActionableInterfaceSetActionTargetValueFieldCallback :: Maybe ActionableInterfaceSetActionTargetValueFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ActionableInterfaceSetActionTargetValueFieldCallback``.

wrap_ActionableInterfaceSetActionTargetValueFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback)) -> ActionableInterfaceSetActionTargetValueFieldCallback -> C_ActionableInterfaceSetActionTargetValueFieldCallback Source #

Wrap a `ActionableInterfaceSetActionTargetValueFieldCallback` into a `C_ActionableInterfaceSetActionTargetValueFieldCallback`.

## 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 -> CSize -> 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.
-> CSize | `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.
-> CSize | `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.
-> CSize | `length`: Length of the text.
-> Ptr () | `data`: the `userData` supplied to `clipboardRequestRichText`.
-> m () |

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

genClosure_ClipboardRichTextReceivedFunc :: MonadIO m => ClipboardRichTextReceivedFunc -> m (GClosure C_ClipboardRichTextReceivedFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardRichTextReceivedFunc``.

noClipboardRichTextReceivedFunc_WithClosures :: Maybe ClipboardRichTextReceivedFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardRichTextReceivedFunc_WithClosures``.

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

Wrap a `ClipboardRichTextReceivedFunc` into a `C_ClipboardRichTextReceivedFunc`.

## ClipboardTargetsReceivedFunc

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

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

type ClipboardTargetsReceivedFunc Source #

Arguments

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

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

Since: 2.4

type ClipboardTargetsReceivedFunc_WithClosures Source #

Arguments

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

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

Since: 2.4

drop_closures_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> ClipboardTargetsReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardTargetsReceivedFunc Source #

Arguments

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

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

genClosure_ClipboardTargetsReceivedFunc :: MonadIO m => ClipboardTargetsReceivedFunc -> m (GClosure C_ClipboardTargetsReceivedFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardTargetsReceivedFunc``.

noClipboardTargetsReceivedFunc_WithClosures :: Maybe ClipboardTargetsReceivedFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardTargetsReceivedFunc_WithClosures``.

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

Wrap a `ClipboardTargetsReceivedFunc` into a `C_ClipboardTargetsReceivedFunc`.

## ClipboardTextReceivedFunc

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

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

type ClipboardTextReceivedFunc Source #

Arguments

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

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

type ClipboardTextReceivedFunc_WithClosures Source #

Arguments

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

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

drop_closures_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> ClipboardTextReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardTextReceivedFunc Source #

Arguments

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

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

genClosure_ClipboardTextReceivedFunc :: MonadIO m => ClipboardTextReceivedFunc -> m (GClosure C_ClipboardTextReceivedFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardTextReceivedFunc``.

noClipboardTextReceivedFunc_WithClosures :: Maybe ClipboardTextReceivedFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardTextReceivedFunc_WithClosures``.

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

Wrap a `ClipboardTextReceivedFunc` into a `C_ClipboardTextReceivedFunc`.

## ClipboardURIReceivedFunc

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

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

type ClipboardURIReceivedFunc Source #

Arguments

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

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

Since: 2.14

type ClipboardURIReceivedFunc_WithClosures Source #

Arguments

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

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

Since: 2.14

drop_closures_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> ClipboardURIReceivedFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ClipboardURIReceivedFunc Source #

Arguments

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

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

genClosure_ClipboardURIReceivedFunc :: MonadIO m => ClipboardURIReceivedFunc -> m (GClosure C_ClipboardURIReceivedFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardURIReceivedFunc``.

noClipboardURIReceivedFunc_WithClosures :: Maybe ClipboardURIReceivedFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClipboardURIReceivedFunc_WithClosures``.

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

Wrap a `ClipboardURIReceivedFunc` into a `C_ClipboardURIReceivedFunc`.

## ColorSelectionChangePaletteFunc

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

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

type ColorSelectionChangePaletteFunc Source #

Arguments

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

Deprecated: (Since version 3.4)

No description available in the introspection data.

dynamic_ColorSelectionChangePaletteFunc Source #

Arguments

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

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

genClosure_ColorSelectionChangePaletteFunc :: MonadIO m => ColorSelectionChangePaletteFunc -> m (GClosure C_ColorSelectionChangePaletteFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ColorSelectionChangePaletteFunc``.

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

Wrap a `ColorSelectionChangePaletteFunc` into a `C_ColorSelectionChangePaletteFunc`.

## ColorSelectionChangePaletteWithScreenFunc

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

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

type ColorSelectionChangePaletteWithScreenFunc Source #

Arguments

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

Deprecated: (Since version 3.4)

No description available in the introspection data.

Since: 2.2

dynamic_ColorSelectionChangePaletteWithScreenFunc Source #

Arguments

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

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

genClosure_ColorSelectionChangePaletteWithScreenFunc :: MonadIO m => ColorSelectionChangePaletteWithScreenFunc -> m (GClosure C_ColorSelectionChangePaletteWithScreenFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ColorSelectionChangePaletteWithScreenFunc``.

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

Wrap a `ColorSelectionChangePaletteWithScreenFunc` into a `C_ColorSelectionChangePaletteWithScreenFunc`.

## ContainerClassAddFieldCallback

type C_ContainerClassAddFieldCallback = Ptr Container -> Ptr Widget -> IO () Source #

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

type ContainerClassAddFieldCallback Source #

Arguments

= Container | `container`: a `Container`
-> Widget | `widget`: a widget to be placed inside `container`
-> IO () |

No description available in the introspection data.

dynamic_ContainerClassAddFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) |
=> FunPtr C_ContainerClassAddFieldCallback |
-> a | `container`: a `Container`
-> b | `widget`: a widget to be placed inside `container`
-> m () |

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

genClosure_ContainerClassAddFieldCallback :: MonadIO m => ContainerClassAddFieldCallback -> m (GClosure C_ContainerClassAddFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassAddFieldCallback :: C_ContainerClassAddFieldCallback -> IO (FunPtr C_ContainerClassAddFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassAddFieldCallback`.

noContainerClassAddFieldCallback :: Maybe ContainerClassAddFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassAddFieldCallback``.

wrap_ContainerClassAddFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassAddFieldCallback)) -> ContainerClassAddFieldCallback -> C_ContainerClassAddFieldCallback Source #

Wrap a `ContainerClassAddFieldCallback` into a `C_ContainerClassAddFieldCallback`.

## ContainerClassCheckResizeFieldCallback

type C_ContainerClassCheckResizeFieldCallback = Ptr Container -> IO () Source #

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

type ContainerClassCheckResizeFieldCallback = Container -> IO () Source #

No description available in the introspection data.

dynamic_ContainerClassCheckResizeFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassCheckResizeFieldCallback -> a -> m () Source #

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

genClosure_ContainerClassCheckResizeFieldCallback :: MonadIO m => ContainerClassCheckResizeFieldCallback -> m (GClosure C_ContainerClassCheckResizeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassCheckResizeFieldCallback :: C_ContainerClassCheckResizeFieldCallback -> IO (FunPtr C_ContainerClassCheckResizeFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassCheckResizeFieldCallback`.

noContainerClassCheckResizeFieldCallback :: Maybe ContainerClassCheckResizeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassCheckResizeFieldCallback``.

wrap_ContainerClassCheckResizeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)) -> ContainerClassCheckResizeFieldCallback -> C_ContainerClassCheckResizeFieldCallback Source #

Wrap a `ContainerClassCheckResizeFieldCallback` into a `C_ContainerClassCheckResizeFieldCallback`.

## ContainerClassChildTypeFieldCallback

type C_ContainerClassChildTypeFieldCallback = Ptr Container -> IO CGType Source #

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

type ContainerClassChildTypeFieldCallback Source #

Arguments

= Container | `container`: a `Container`
-> IO GType | Returns: a `GType`.

No description available in the introspection data.

dynamic_ContainerClassChildTypeFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsContainer a) |
=> FunPtr C_ContainerClassChildTypeFieldCallback |
-> a | `container`: a `Container`
-> m GType | Returns: a `GType`.

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

genClosure_ContainerClassChildTypeFieldCallback :: MonadIO m => ContainerClassChildTypeFieldCallback -> m (GClosure C_ContainerClassChildTypeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassChildTypeFieldCallback :: C_ContainerClassChildTypeFieldCallback -> IO (FunPtr C_ContainerClassChildTypeFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassChildTypeFieldCallback`.

noContainerClassChildTypeFieldCallback :: Maybe ContainerClassChildTypeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassChildTypeFieldCallback``.

wrap_ContainerClassChildTypeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)) -> ContainerClassChildTypeFieldCallback -> C_ContainerClassChildTypeFieldCallback Source #

Wrap a `ContainerClassChildTypeFieldCallback` into a `C_ContainerClassChildTypeFieldCallback`.

## ContainerClassCompositeNameFieldCallback

type C_ContainerClassCompositeNameFieldCallback = Ptr Container -> Ptr Widget -> IO CString Source #

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

type ContainerClassCompositeNameFieldCallback = Container -> Widget -> IO Text Source #

No description available in the introspection data.

dynamic_ContainerClassCompositeNameFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassCompositeNameFieldCallback -> a -> b -> m Text Source #

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

genClosure_ContainerClassCompositeNameFieldCallback :: MonadIO m => ContainerClassCompositeNameFieldCallback -> m (GClosure C_ContainerClassCompositeNameFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassCompositeNameFieldCallback :: C_ContainerClassCompositeNameFieldCallback -> IO (FunPtr C_ContainerClassCompositeNameFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassCompositeNameFieldCallback`.

noContainerClassCompositeNameFieldCallback :: Maybe ContainerClassCompositeNameFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassCompositeNameFieldCallback``.

wrap_ContainerClassCompositeNameFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)) -> ContainerClassCompositeNameFieldCallback -> C_ContainerClassCompositeNameFieldCallback Source #

Wrap a `ContainerClassCompositeNameFieldCallback` into a `C_ContainerClassCompositeNameFieldCallback`.

## ContainerClassForallFieldCallback

type C_ContainerClassForallFieldCallback = Ptr Container -> CInt -> FunPtr C_Callback -> Ptr () -> IO () Source #

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

type ContainerClassForallFieldCallback Source #

Arguments

= Container | `container`: a `Container`
-> Bool |
-> Callback_WithClosures | `callback`: a callback
-> IO () |

No description available in the introspection data.

type ContainerClassForallFieldCallback_WithClosures Source #

Arguments

= Container | `container`: a `Container`
-> Bool |
-> Callback_WithClosures | `callback`: a callback
-> Ptr () | `callbackData`: callback user data
-> IO () |

No description available in the introspection data.

drop_closures_ContainerClassForallFieldCallback :: ContainerClassForallFieldCallback -> ContainerClassForallFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ContainerClassForallFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsContainer a) |
=> FunPtr C_ContainerClassForallFieldCallback |
-> a | `container`: a `Container`
-> Bool |
-> Callback_WithClosures | `callback`: a callback
-> Ptr () | `callbackData`: callback user data
-> m () |

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

genClosure_ContainerClassForallFieldCallback :: MonadIO m => ContainerClassForallFieldCallback -> m (GClosure C_ContainerClassForallFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassForallFieldCallback :: C_ContainerClassForallFieldCallback -> IO (FunPtr C_ContainerClassForallFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassForallFieldCallback`.

noContainerClassForallFieldCallback :: Maybe ContainerClassForallFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassForallFieldCallback``.

noContainerClassForallFieldCallback_WithClosures :: Maybe ContainerClassForallFieldCallback_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassForallFieldCallback_WithClosures``.

wrap_ContainerClassForallFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassForallFieldCallback)) -> ContainerClassForallFieldCallback_WithClosures -> C_ContainerClassForallFieldCallback Source #

Wrap a `ContainerClassForallFieldCallback` into a `C_ContainerClassForallFieldCallback`.

## ContainerClassGetChildPropertyFieldCallback

type C_ContainerClassGetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

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

type ContainerClassGetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_ContainerClassGetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassGetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m () Source #

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

genClosure_ContainerClassGetChildPropertyFieldCallback :: MonadIO m => ContainerClassGetChildPropertyFieldCallback -> m (GClosure C_ContainerClassGetChildPropertyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassGetChildPropertyFieldCallback :: C_ContainerClassGetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassGetChildPropertyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassGetChildPropertyFieldCallback`.

noContainerClassGetChildPropertyFieldCallback :: Maybe ContainerClassGetChildPropertyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassGetChildPropertyFieldCallback``.

wrap_ContainerClassGetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetChildPropertyFieldCallback)) -> ContainerClassGetChildPropertyFieldCallback -> C_ContainerClassGetChildPropertyFieldCallback Source #

Wrap a `ContainerClassGetChildPropertyFieldCallback` into a `C_ContainerClassGetChildPropertyFieldCallback`.

## ContainerClassGetPathForChildFieldCallback

type C_ContainerClassGetPathForChildFieldCallback = Ptr Container -> Ptr Widget -> IO (Ptr WidgetPath) Source #

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

type ContainerClassGetPathForChildFieldCallback Source #

Arguments

= Container | `container`: a `Container`
-> Widget | `child`: a child of `container`
-> IO WidgetPath | Returns: A newly created `WidgetPath`

No description available in the introspection data.

dynamic_ContainerClassGetPathForChildFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) |
=> FunPtr C_ContainerClassGetPathForChildFieldCallback |
-> a | `container`: a `Container`
-> b | `child`: a child of `container`
-> m WidgetPath | Returns: A newly created `WidgetPath`

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

genClosure_ContainerClassGetPathForChildFieldCallback :: MonadIO m => ContainerClassGetPathForChildFieldCallback -> m (GClosure C_ContainerClassGetPathForChildFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassGetPathForChildFieldCallback :: C_ContainerClassGetPathForChildFieldCallback -> IO (FunPtr C_ContainerClassGetPathForChildFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassGetPathForChildFieldCallback`.

noContainerClassGetPathForChildFieldCallback :: Maybe ContainerClassGetPathForChildFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassGetPathForChildFieldCallback``.

wrap_ContainerClassGetPathForChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)) -> ContainerClassGetPathForChildFieldCallback -> C_ContainerClassGetPathForChildFieldCallback Source #

Wrap a `ContainerClassGetPathForChildFieldCallback` into a `C_ContainerClassGetPathForChildFieldCallback`.

## ContainerClassRemoveFieldCallback

type C_ContainerClassRemoveFieldCallback = Ptr Container -> Ptr Widget -> IO () Source #

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

type ContainerClassRemoveFieldCallback Source #

Arguments

= Container | `container`: a `Container`
-> Widget | `widget`: a current child of `container`
-> IO () |

No description available in the introspection data.

dynamic_ContainerClassRemoveFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) |
=> FunPtr C_ContainerClassRemoveFieldCallback |
-> a | `container`: a `Container`
-> b | `widget`: a current child of `container`
-> m () |

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

genClosure_ContainerClassRemoveFieldCallback :: MonadIO m => ContainerClassRemoveFieldCallback -> m (GClosure C_ContainerClassRemoveFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassRemoveFieldCallback :: C_ContainerClassRemoveFieldCallback -> IO (FunPtr C_ContainerClassRemoveFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassRemoveFieldCallback`.

noContainerClassRemoveFieldCallback :: Maybe ContainerClassRemoveFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassRemoveFieldCallback``.

wrap_ContainerClassRemoveFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassRemoveFieldCallback)) -> ContainerClassRemoveFieldCallback -> C_ContainerClassRemoveFieldCallback Source #

Wrap a `ContainerClassRemoveFieldCallback` into a `C_ContainerClassRemoveFieldCallback`.

## ContainerClassSetChildPropertyFieldCallback

type C_ContainerClassSetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

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

type ContainerClassSetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_ContainerClassSetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassSetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m () Source #

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

genClosure_ContainerClassSetChildPropertyFieldCallback :: MonadIO m => ContainerClassSetChildPropertyFieldCallback -> m (GClosure C_ContainerClassSetChildPropertyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassSetChildPropertyFieldCallback :: C_ContainerClassSetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassSetChildPropertyFieldCallback`.

noContainerClassSetChildPropertyFieldCallback :: Maybe ContainerClassSetChildPropertyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassSetChildPropertyFieldCallback``.

wrap_ContainerClassSetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)) -> ContainerClassSetChildPropertyFieldCallback -> C_ContainerClassSetChildPropertyFieldCallback Source #

Wrap a `ContainerClassSetChildPropertyFieldCallback` into a `C_ContainerClassSetChildPropertyFieldCallback`.

## ContainerClassSetFocusChildFieldCallback

type C_ContainerClassSetFocusChildFieldCallback = Ptr Container -> Ptr Widget -> IO () Source #

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

type ContainerClassSetFocusChildFieldCallback Source #

Arguments

= Container | `container`: a `Container`
-> Maybe Widget | `child`: a `Widget`, or `Nothing`
-> IO () |

No description available in the introspection data.

dynamic_ContainerClassSetFocusChildFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) |
=> FunPtr C_ContainerClassSetFocusChildFieldCallback |
-> a | `container`: a `Container`
-> Maybe b | `child`: a `Widget`, or `Nothing`
-> m () |

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

genClosure_ContainerClassSetFocusChildFieldCallback :: MonadIO m => ContainerClassSetFocusChildFieldCallback -> m (GClosure C_ContainerClassSetFocusChildFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ContainerClassSetFocusChildFieldCallback :: C_ContainerClassSetFocusChildFieldCallback -> IO (FunPtr C_ContainerClassSetFocusChildFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ContainerClassSetFocusChildFieldCallback`.

noContainerClassSetFocusChildFieldCallback :: Maybe ContainerClassSetFocusChildFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ContainerClassSetFocusChildFieldCallback``.

wrap_ContainerClassSetFocusChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetFocusChildFieldCallback)) -> ContainerClassSetFocusChildFieldCallback -> C_ContainerClassSetFocusChildFieldCallback Source #

Wrap a `ContainerClassSetFocusChildFieldCallback` into a `C_ContainerClassSetFocusChildFieldCallback`.

## EntryCompletionMatchFunc

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

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

type EntryCompletionMatchFunc Source #

Arguments

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

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

type EntryCompletionMatchFunc_WithClosures Source #

Arguments

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

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

drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_EntryCompletionMatchFunc Source #

Arguments

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

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

genClosure_EntryCompletionMatchFunc :: MonadIO m => EntryCompletionMatchFunc -> m (GClosure C_EntryCompletionMatchFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `EntryCompletionMatchFunc``.

noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `EntryCompletionMatchFunc_WithClosures``.

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

Wrap a `EntryCompletionMatchFunc` into a `C_EntryCompletionMatchFunc`.

## FileFilterFunc

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

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

type FileFilterFunc Source #

Arguments

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

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

type FileFilterFunc_WithClosures Source #

Arguments

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

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

drop_closures_FileFilterFunc :: FileFilterFunc -> FileFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FileFilterFunc Source #

Arguments

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

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

genClosure_FileFilterFunc :: MonadIO m => FileFilterFunc -> m (GClosure C_FileFilterFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noFileFilterFunc :: Maybe FileFilterFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `FileFilterFunc``.

noFileFilterFunc_WithClosures :: Maybe FileFilterFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `FileFilterFunc_WithClosures``.

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

Wrap a `FileFilterFunc` into a `C_FileFilterFunc`.

## FlowBoxCreateWidgetFunc

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

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

type FlowBoxCreateWidgetFunc Source #

Arguments

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

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

Since: 3.18

type FlowBoxCreateWidgetFunc_WithClosures Source #

Arguments

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

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

Since: 3.18

drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxCreateWidgetFunc Source #

Arguments

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

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

genClosure_FlowBoxCreateWidgetFunc :: MonadIO m => FlowBoxCreateWidgetFunc -> m (GClosure C_FlowBoxCreateWidgetFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxCreateWidgetFunc``.

noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxCreateWidgetFunc_WithClosures``.

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

Wrap a `FlowBoxCreateWidgetFunc` into a `C_FlowBoxCreateWidgetFunc`.

## FlowBoxFilterFunc

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

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

type FlowBoxFilterFunc Source #

Arguments

= FlowBoxChild | `child`: a `FlowBoxChild` that may be filtered
-> IO Bool | Returns: `True` if the row should be visible, `False` otherwise

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

Since: 3.12

type FlowBoxFilterFunc_WithClosures Source #

Arguments

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

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

Since: 3.12

drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxFilterFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxFilterFunc``.

noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxFilterFunc_WithClosures``.

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

Wrap a `FlowBoxFilterFunc` into a `C_FlowBoxFilterFunc`.

## FlowBoxForeachFunc

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

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

type FlowBoxForeachFunc Source #

Arguments

= FlowBox | `box`: a `FlowBox`
-> FlowBoxChild | `child`: a `FlowBoxChild`
-> IO () |

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

Since: 3.12

type FlowBoxForeachFunc_WithClosures Source #

Arguments

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

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

Since: 3.12

drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxForeachFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxForeachFunc``.

noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxForeachFunc_WithClosures``.

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

Wrap a `FlowBoxForeachFunc` into a `C_FlowBoxForeachFunc`.

## FlowBoxSortFunc

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

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

type FlowBoxSortFunc Source #

Arguments

= FlowBoxChild | `child1`: the first child
-> FlowBoxChild | `child2`: the second child
-> IO Int32 | Returns: < 0 if `child1` should be before `child2`, 0 if the are equal, and > 0 otherwise

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

Since: 3.12

type FlowBoxSortFunc_WithClosures Source #

Arguments

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

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

Since: 3.12

drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FlowBoxSortFunc Source #

Arguments

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

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

genClosure_FlowBoxSortFunc :: MonadIO m => FlowBoxSortFunc -> m (GClosure C_FlowBoxSortFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noFlowBoxSortFunc :: Maybe FlowBoxSortFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxSortFunc``.

noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `FlowBoxSortFunc_WithClosures``.

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

Wrap a `FlowBoxSortFunc` into a `C_FlowBoxSortFunc`.

## FontFilterFunc

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

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

type FontFilterFunc Source #

Arguments

= FontFamily | `family`: a `FontFamily`
-> FontFace | `face`: a `FontFace` belonging to `family`
-> IO Bool | Returns: `True` if the font should be displayed

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

type FontFilterFunc_WithClosures Source #

Arguments

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

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

drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FontFilterFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noFontFilterFunc :: Maybe FontFilterFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `FontFilterFunc``.

noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `FontFilterFunc_WithClosures``.

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

Wrap a `FontFilterFunc` into a `C_FontFilterFunc`.

## IconViewForeachFunc

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

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

type IconViewForeachFunc Source #

Arguments

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

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

type IconViewForeachFunc_WithClosures Source #

Arguments

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

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

drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_IconViewForeachFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noIconViewForeachFunc :: Maybe IconViewForeachFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `IconViewForeachFunc``.

noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `IconViewForeachFunc_WithClosures``.

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

Wrap a `IconViewForeachFunc` into a `C_IconViewForeachFunc`.

## KeySnoopFunc

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

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

type KeySnoopFunc Source #

Arguments

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

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

type KeySnoopFunc_WithClosures Source #

Arguments

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

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

drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_KeySnoopFunc Source #

Arguments

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

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

genClosure_KeySnoopFunc :: MonadIO m => KeySnoopFunc -> m (GClosure C_KeySnoopFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noKeySnoopFunc :: Maybe KeySnoopFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `KeySnoopFunc``.

noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `KeySnoopFunc_WithClosures``.

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

Wrap a `KeySnoopFunc` into a `C_KeySnoopFunc`.

## ListBoxCreateWidgetFunc

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

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

type ListBoxCreateWidgetFunc Source #

Arguments

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

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

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

Since: 3.16

type ListBoxCreateWidgetFunc_WithClosures Source #

Arguments

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

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

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

Since: 3.16

drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxCreateWidgetFunc Source #

Arguments

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

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

genClosure_ListBoxCreateWidgetFunc :: MonadIO m => ListBoxCreateWidgetFunc -> m (GClosure C_ListBoxCreateWidgetFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxCreateWidgetFunc``.

noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxCreateWidgetFunc_WithClosures``.

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

Wrap a `ListBoxCreateWidgetFunc` into a `C_ListBoxCreateWidgetFunc`.

## ListBoxFilterFunc

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

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

type ListBoxFilterFunc Source #

Arguments

= ListBoxRow | `row`: the row that may be filtered
-> IO Bool | Returns: `True` if the row should be visible, `False` otherwise

Will be called whenever the row changes or is added and lets you control if the row should be visible or not.

Since: 3.10

type ListBoxFilterFunc_WithClosures Source #

Arguments

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

Will be called whenever the row changes or is added and lets you control if the row should be visible or not.

Since: 3.10

drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxFilterFunc Source #

Arguments

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

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

genClosure_ListBoxFilterFunc :: MonadIO m => ListBoxFilterFunc -> m (GClosure C_ListBoxFilterFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noListBoxFilterFunc :: Maybe ListBoxFilterFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxFilterFunc``.

noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxFilterFunc_WithClosures``.

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

Wrap a `ListBoxFilterFunc` into a `C_ListBoxFilterFunc`.

## ListBoxForeachFunc

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

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

type ListBoxForeachFunc Source #

Arguments

= ListBox | `box`: a `ListBox`
-> ListBoxRow | `row`: a `ListBoxRow`
-> IO () |

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

Since: 3.14

type ListBoxForeachFunc_WithClosures Source #

Arguments

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

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

Since: 3.14

drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxForeachFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noListBoxForeachFunc :: Maybe ListBoxForeachFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxForeachFunc``.

noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxForeachFunc_WithClosures``.

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

Wrap a `ListBoxForeachFunc` into a `C_ListBoxForeachFunc`.

## ListBoxSortFunc

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

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

type ListBoxSortFunc Source #

Arguments

= ListBoxRow | `row1`: the first row
-> ListBoxRow | `row2`: the second row
-> IO Int32 | Returns: < 0 if `row1` should be before `row2`, 0 if they are equal and > 0 otherwise

Compare two rows to determine which should be first.

Since: 3.10

type ListBoxSortFunc_WithClosures Source #

Arguments

= ListBoxRow | `row1`: the first row
-> ListBoxRow | `row2`: the second row
-> Ptr () | `userData`: user data
-> IO Int32 | Returns: < 0 if `row1` should be before `row2`, 0 if they are equal and > 0 otherwise

Compare two rows to determine which should be first.

Since: 3.10

drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxSortFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) |
=> FunPtr C_ListBoxSortFunc |
-> a | `row1`: the first row
-> b | `row2`: the second row
-> Ptr () | `userData`: user data
-> m Int32 | Returns: < 0 if `row1` should be before `row2`, 0 if they are equal and > 0 otherwise

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

genClosure_ListBoxSortFunc :: MonadIO m => ListBoxSortFunc -> m (GClosure C_ListBoxSortFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noListBoxSortFunc :: Maybe ListBoxSortFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxSortFunc``.

noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxSortFunc_WithClosures``.

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

Wrap a `ListBoxSortFunc` into a `C_ListBoxSortFunc`.

## ListBoxUpdateHeaderFunc

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

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

type ListBoxUpdateHeaderFunc Source #

Arguments

= ListBoxRow | `row`: the row to update
-> Maybe ListBoxRow | `before`: the row before `row`, or `Nothing` if it is first
-> IO () |

Whenever `row` changes or which row is before `row` changes this is called, which lets you update the header on `row`. You may remove or set a new one via `listBoxRowSetHeader` or just change the state of the current header widget.

Since: 3.10

type ListBoxUpdateHeaderFunc_WithClosures Source #

Arguments

= ListBoxRow | `row`: the row to update
-> Maybe ListBoxRow | `before`: the row before `row`, or `Nothing` if it is first
-> Ptr () | `userData`: user data
-> IO () |

Whenever `row` changes or which row is before `row` changes this is called, which lets you update the header on `row`. You may remove or set a new one via `listBoxRowSetHeader` or just change the state of the current header widget.

Since: 3.10

drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ListBoxUpdateHeaderFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) |
=> FunPtr C_ListBoxUpdateHeaderFunc |
-> a | `row`: the row to update
-> Maybe b | `before`: the row before `row`, or `Nothing` if it is first
-> Ptr () | `userData`: user data
-> m () |

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

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

Wrap the callback into a `GClosure`.

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

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

noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxUpdateHeaderFunc``.

noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `ListBoxUpdateHeaderFunc_WithClosures``.

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

Wrap a `ListBoxUpdateHeaderFunc` into a `C_ListBoxUpdateHeaderFunc`.

## MenuDetachFunc

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

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

type MenuDetachFunc Source #

Arguments

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

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

dynamic_MenuDetachFunc Source #

Arguments

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

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

genClosure_MenuDetachFunc :: MonadIO m => MenuDetachFunc -> m (GClosure C_MenuDetachFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noMenuDetachFunc :: Maybe MenuDetachFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `MenuDetachFunc``.

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

Wrap a `MenuDetachFunc` into a `C_MenuDetachFunc`.

## MenuPositionFunc

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

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

type MenuPositionFunc Source #

Arguments

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

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

type MenuPositionFunc_WithClosures Source #

Arguments

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

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

drop_closures_MenuPositionFunc :: MenuPositionFunc -> MenuPositionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MenuPositionFunc Source #

Arguments

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

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

genClosure_MenuPositionFunc :: MonadIO m => MenuPositionFunc -> m (GClosure C_MenuPositionFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noMenuPositionFunc :: Maybe MenuPositionFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `MenuPositionFunc``.

noMenuPositionFunc_WithClosures :: Maybe MenuPositionFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `MenuPositionFunc_WithClosures``.

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

Wrap a `MenuPositionFunc` into a `C_MenuPositionFunc`.

## ModuleDisplayInitFunc

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

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

type ModuleDisplayInitFunc Source #

Arguments

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

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

Since: 2.2

dynamic_ModuleDisplayInitFunc Source #

Arguments

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

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

genClosure_ModuleDisplayInitFunc :: MonadIO m => ModuleDisplayInitFunc -> m (GClosure C_ModuleDisplayInitFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ModuleDisplayInitFunc``.

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

Wrap a `ModuleDisplayInitFunc` into a `C_ModuleDisplayInitFunc`.

## ModuleInitFunc

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

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

type ModuleInitFunc Source #

Arguments

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

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

dynamic_ModuleInitFunc Source #

Arguments

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

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

genClosure_ModuleInitFunc :: MonadIO m => ModuleInitFunc -> m (GClosure C_ModuleInitFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noModuleInitFunc :: Maybe ModuleInitFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ModuleInitFunc``.

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

Wrap a `ModuleInitFunc` into a `C_ModuleInitFunc`.

## PageSetupDoneFunc

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

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

type PageSetupDoneFunc Source #

Arguments

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

The type of function that is passed to `printRunPageSetupDialogAsync`.

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

type PageSetupDoneFunc_WithClosures Source #

Arguments

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

The type of function that is passed to `printRunPageSetupDialogAsync`.

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

drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_PageSetupDoneFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsPageSetup a) |
=> FunPtr C_PageSetupDoneFunc |
-> a | `pageSetup`: the `PageSetup` that has been
-> Ptr () | `data`: user data that has been passed to `printRunPageSetupDialogAsync`
-> m () |

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

genClosure_PageSetupDoneFunc :: MonadIO m => PageSetupDoneFunc -> m (GClosure C_PageSetupDoneFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noPageSetupDoneFunc :: Maybe PageSetupDoneFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `PageSetupDoneFunc``.

noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `PageSetupDoneFunc_WithClosures``.

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

Wrap a `PageSetupDoneFunc` into a `C_PageSetupDoneFunc`.

## PrintSettingsFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_PrintSettingsFunc :: MonadIO m => PrintSettingsFunc -> m (GClosure C_PrintSettingsFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noPrintSettingsFunc :: Maybe PrintSettingsFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `PrintSettingsFunc``.

noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `PrintSettingsFunc_WithClosures``.

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

Wrap a `PrintSettingsFunc` into a `C_PrintSettingsFunc`.

## RcPropertyParser

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

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

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

No description available in the introspection data.

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

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

genClosure_RcPropertyParser :: MonadIO m => RcPropertyParser -> m (GClosure C_RcPropertyParser) Source #

Wrap the callback into a `GClosure`.

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

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

noRcPropertyParser :: Maybe RcPropertyParser Source #

A convenience synonym for ``Nothing` :: `Maybe` `RcPropertyParser``.

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

Wrap a `RcPropertyParser` into a `C_RcPropertyParser`.

## RecentFilterFunc

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

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

type RecentFilterFunc Source #

Arguments

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

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

type RecentFilterFunc_WithClosures Source #

Arguments

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

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

drop_closures_RecentFilterFunc :: RecentFilterFunc -> RecentFilterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_RecentFilterFunc Source #

Arguments

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

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

genClosure_RecentFilterFunc :: MonadIO m => RecentFilterFunc -> m (GClosure C_RecentFilterFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noRecentFilterFunc :: Maybe RecentFilterFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `RecentFilterFunc``.

noRecentFilterFunc_WithClosures :: Maybe RecentFilterFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `RecentFilterFunc_WithClosures``.

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

Wrap a `RecentFilterFunc` into a `C_RecentFilterFunc`.

## RecentSortFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_RecentSortFunc :: RecentSortFunc -> RecentSortFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_RecentSortFunc :: MonadIO m => RecentSortFunc -> m (GClosure C_RecentSortFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noRecentSortFunc :: Maybe RecentSortFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `RecentSortFunc``.

noRecentSortFunc_WithClosures :: Maybe RecentSortFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `RecentSortFunc_WithClosures``.

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

Wrap a `RecentSortFunc` into a `C_RecentSortFunc`.

## StylePropertyParser

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

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

type StylePropertyParser Source #

Arguments

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

No description available in the introspection data.

dynamic_StylePropertyParser Source #

Arguments

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

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

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

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

noStylePropertyParser :: Maybe StylePropertyParser Source #

A convenience synonym for ``Nothing` :: `Maybe` `StylePropertyParser``.

## TextBufferDeserializeFunc

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

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

type TextBufferDeserializeFunc Source #

Arguments

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

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

type TextBufferDeserializeFunc_WithClosures Source #

Arguments

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

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

drop_closures_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> TextBufferDeserializeFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextBufferDeserializeFunc Source #

Arguments

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

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

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

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

noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextBufferDeserializeFunc``.

noTextBufferDeserializeFunc_WithClosures :: Maybe TextBufferDeserializeFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextBufferDeserializeFunc_WithClosures``.

## TextBufferSerializeFunc

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

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

type TextBufferSerializeFunc Source #

Arguments

= TextBuffer | `registerBuffer`: the `TextBuffer` for which the format is registered
-> TextBuffer | `contentBuffer`: the `TextBuffer` to serialize
-> TextIter | `start`: start of the block of text to serialize
-> TextIter | `end`: end of the block of text to serialize
-> IO (Maybe ByteString) | Returns: a newly-allocated array of guint8 which contains the serialized data, or `Nothing` if an error occurred

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

type TextBufferSerializeFunc_WithClosures Source #

Arguments

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

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

drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextBufferSerializeFunc Source #

Arguments

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

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

genClosure_TextBufferSerializeFunc :: MonadIO m => TextBufferSerializeFunc -> m (GClosure C_TextBufferSerializeFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextBufferSerializeFunc``.

noTextBufferSerializeFunc_WithClosures :: Maybe TextBufferSerializeFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextBufferSerializeFunc_WithClosures``.

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

Wrap a `TextBufferSerializeFunc` into a `C_TextBufferSerializeFunc`.

## TextCharPredicate

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

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

type TextCharPredicate = Char -> IO Bool Source #

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_TextCharPredicate :: MonadIO m => TextCharPredicate -> m (GClosure C_TextCharPredicate) Source #

Wrap the callback into a `GClosure`.

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

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

noTextCharPredicate :: Maybe TextCharPredicate Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextCharPredicate``.

noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextCharPredicate_WithClosures``.

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

Wrap a `TextCharPredicate` into a `C_TextCharPredicate`.

## TextTagTableForeach

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

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

type TextTagTableForeach Source #

Arguments

= TextTag | `tag`: the `TextTag`
-> IO () |

No description available in the introspection data.

type TextTagTableForeach_WithClosures Source #

Arguments

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

No description available in the introspection data.

drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TextTagTableForeach Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noTextTagTableForeach :: Maybe TextTagTableForeach Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextTagTableForeach``.

noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TextTagTableForeach_WithClosures``.

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

Wrap a `TextTagTableForeach` into a `C_TextTagTableForeach`.

## TickCallback

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

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

type TickCallback Source #

Arguments

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

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

Since: 3.8

type TickCallback_WithClosures Source #

Arguments

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

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

Since: 3.8

drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TickCallback Source #

Arguments

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

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

genClosure_TickCallback :: MonadIO m => TickCallback -> m (GClosure C_TickCallback) Source #

Wrap the callback into a `GClosure`.

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

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

noTickCallback :: Maybe TickCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `TickCallback``.

noTickCallback_WithClosures :: Maybe TickCallback_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TickCallback_WithClosures``.

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

Wrap a `TickCallback` into a `C_TickCallback`.

## TranslateFunc

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

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

type TranslateFunc Source #

Arguments

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

Deprecated: (Since version 3.10)

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

type TranslateFunc_WithClosures Source #

Arguments

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

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

drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TranslateFunc Source #

Arguments

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

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

genClosure_TranslateFunc :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTranslateFunc :: Maybe TranslateFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TranslateFunc``.

noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TranslateFunc_WithClosures``.

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

Wrap a `TranslateFunc` into a `C_TranslateFunc`.

## TreeCellDataFunc

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

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

type TreeCellDataFunc Source #

Arguments

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

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

type TreeCellDataFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeCellDataFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noTreeCellDataFunc :: Maybe TreeCellDataFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeCellDataFunc``.

noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeCellDataFunc_WithClosures``.

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

Wrap a `TreeCellDataFunc` into a `C_TreeCellDataFunc`.

## TreeDestroyCountFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TreeDestroyCountFunc :: TreeDestroyCountFunc -> TreeDestroyCountFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_TreeDestroyCountFunc :: MonadIO m => TreeDestroyCountFunc -> m (GClosure C_TreeDestroyCountFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeDestroyCountFunc``.

noTreeDestroyCountFunc_WithClosures :: Maybe TreeDestroyCountFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeDestroyCountFunc_WithClosures``.

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

Wrap a `TreeDestroyCountFunc` into a `C_TreeDestroyCountFunc`.

## TreeIterCompareFunc

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

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

type TreeIterCompareFunc Source #

Arguments

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

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

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

type TreeIterCompareFunc_WithClosures Source #

Arguments

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

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

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

drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeIterCompareFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noTreeIterCompareFunc :: Maybe TreeIterCompareFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeIterCompareFunc``.

noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeIterCompareFunc_WithClosures``.

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

Wrap a `TreeIterCompareFunc` into a `C_TreeIterCompareFunc`.

## TreeModelFilterModifyFunc

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

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

type TreeModelFilterModifyFunc Source #

Arguments

= TreeModel | `model`: the `TreeModelFilter`
-> TreeIter | `iter`: a `TreeIter` pointing to the row whose display values are determined
-> Int32 | `column`: the column whose display value is determined
-> IO GValue |

A function which calculates display values from raw values in the model. It must fill `value` with the display value for the column `column` in the row indicated by `iter`.

Since this function is called for each data access, it’s not a particularly efficient operation.

type TreeModelFilterModifyFunc_WithClosures Source #

Arguments

= TreeModel | `model`: the `TreeModelFilter`
-> TreeIter | `iter`: a `TreeIter` pointing to the row whose display values are determined
-> Int32 | `column`: the column whose display value is determined
-> Ptr () | `data`: user data given to `gtk_tree_model_filter_set_modify_func()`
-> IO GValue |

A function which calculates display values from raw values in the model. It must fill `value` with the display value for the column `column` in the row indicated by `iter`.

Since this function is called for each data access, it’s not a particularly efficient operation.

drop_closures_TreeModelFilterModifyFunc :: TreeModelFilterModifyFunc -> TreeModelFilterModifyFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelFilterModifyFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) |
=> FunPtr C_TreeModelFilterModifyFunc |
-> a | `model`: the `TreeModelFilter`
-> TreeIter | `iter`: a `TreeIter` pointing to the row whose display values are determined
-> Int32 | `column`: the column whose display value is determined
-> Ptr () | `data`: user data given to `gtk_tree_model_filter_set_modify_func()`
-> m GValue |

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

genClosure_TreeModelFilterModifyFunc :: MonadIO m => TreeModelFilterModifyFunc -> m (GClosure C_TreeModelFilterModifyFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeModelFilterModifyFunc``.

noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeModelFilterModifyFunc_WithClosures``.

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

Wrap a `TreeModelFilterModifyFunc` into a `C_TreeModelFilterModifyFunc`.

## TreeModelFilterVisibleFunc

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

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

type TreeModelFilterVisibleFunc Source #

Arguments

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

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

type TreeModelFilterVisibleFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelFilterVisibleFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) |
=> FunPtr C_TreeModelFilterVisibleFunc |
-> a | `model`: the child model of the `TreeModelFilter`
-> TreeIter | `iter`: a `TreeIter` pointing to the row in `model` whose visibility is determined
-> Ptr () | `data`: user data given to `treeModelFilterSetVisibleFunc`
-> m Bool | Returns: Whether the row indicated by `iter` is visible.

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

genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeModelFilterVisibleFunc``.

noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeModelFilterVisibleFunc_WithClosures``.

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

Wrap a `TreeModelFilterVisibleFunc` into a `C_TreeModelFilterVisibleFunc`.

## TreeModelForeachFunc

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

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

type TreeModelForeachFunc Source #

Arguments

= TreeModel | `model`: the `TreeModel` being iterated
-> TreePath | `path`: the current `TreePath`
-> TreeIter | `iter`: the current `TreeIter`
-> IO Bool | Returns: `True` to stop iterating, `False` to continue

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

type TreeModelForeachFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeModelForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) |
=> FunPtr C_TreeModelForeachFunc |
-> a | `model`: the `TreeModel` being iterated
-> TreePath | `path`: the current `TreePath`
-> TreeIter | `iter`: the current `TreeIter`
-> Ptr () | `data`: The user data passed to `treeModelForeach`
-> m Bool | Returns: `True` to stop iterating, `False` to continue

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

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

Wrap the callback into a `GClosure`.

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

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

noTreeModelForeachFunc :: Maybe TreeModelForeachFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeModelForeachFunc``.

noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeModelForeachFunc_WithClosures``.

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

Wrap a `TreeModelForeachFunc` into a `C_TreeModelForeachFunc`.

## TreeSelectionForeachFunc

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

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

type TreeSelectionForeachFunc Source #

Arguments

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

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

type TreeSelectionForeachFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeSelectionForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) |
=> FunPtr C_TreeSelectionForeachFunc |
-> a | `model`: The `TreeModel` being viewed
-> TreePath | `path`: The `TreePath` of a selected row
-> TreeIter | `iter`: A `TreeIter` pointing to a selected row
-> Ptr () | `data`: user data
-> m () |

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

genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeSelectionForeachFunc``.

noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeSelectionForeachFunc_WithClosures``.

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

Wrap a `TreeSelectionForeachFunc` into a `C_TreeSelectionForeachFunc`.

## TreeSelectionFunc

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

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

type TreeSelectionFunc Source #

Arguments

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

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

type TreeSelectionFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeSelectionFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noTreeSelectionFunc :: Maybe TreeSelectionFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeSelectionFunc``.

noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeSelectionFunc_WithClosures``.

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

Wrap a `TreeSelectionFunc` into a `C_TreeSelectionFunc`.

## TreeViewColumnDropFunc

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

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

type TreeViewColumnDropFunc Source #

Arguments

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

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

type TreeViewColumnDropFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewColumnDropFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d) |
=> FunPtr C_TreeViewColumnDropFunc |
-> a | `treeView`: A `TreeView`
-> b | `column`: The `TreeViewColumn` being dragged
-> c | `prevColumn`: A `TreeViewColumn` on one side of `column`
-> d | `nextColumn`: A `TreeViewColumn` on the other side of `column`
-> Ptr () | `data`: user data
-> m Bool | Returns: `True`, if `column` can be dropped in this spot

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

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

Wrap the callback into a `GClosure`.

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

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

noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewColumnDropFunc``.

noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewColumnDropFunc_WithClosures``.

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

Wrap a `TreeViewColumnDropFunc` into a `C_TreeViewColumnDropFunc`.

## TreeViewMappingFunc

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

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

type TreeViewMappingFunc Source #

Arguments

= TreeView | `treeView`: A `TreeView`
-> TreePath | `path`: The path that’s expanded
-> IO () |

Function used for `treeViewMapExpandedRows`.

type TreeViewMappingFunc_WithClosures Source #

Arguments

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

Function used for `treeViewMapExpandedRows`.

drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewMappingFunc Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noTreeViewMappingFunc :: Maybe TreeViewMappingFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewMappingFunc``.

noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewMappingFunc_WithClosures``.

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

Wrap a `TreeViewMappingFunc` into a `C_TreeViewMappingFunc`.

## TreeViewRowSeparatorFunc

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

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

type TreeViewRowSeparatorFunc Source #

Arguments

= TreeModel | `model`: the `TreeModel`
-> TreeIter | `iter`: a `TreeIter` pointing at a row in `model`
-> IO Bool | Returns: `True` if the row is a separator

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

type TreeViewRowSeparatorFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewRowSeparatorFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTreeModel a) |
=> FunPtr C_TreeViewRowSeparatorFunc |
-> a | `model`: the `TreeModel`
-> TreeIter | `iter`: a `TreeIter` pointing at a row in `model`
-> Ptr () | `data`: user data
-> m Bool | Returns: `True` if the row is a separator

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

genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewRowSeparatorFunc``.

noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewRowSeparatorFunc_WithClosures``.

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

Wrap a `TreeViewRowSeparatorFunc` into a `C_TreeViewRowSeparatorFunc`.

## TreeViewSearchEqualFunc

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

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

type TreeViewSearchEqualFunc Source #

Arguments

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

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

type TreeViewSearchEqualFunc_WithClosures Source #

Arguments

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

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

drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TreeViewSearchEqualFunc Source #

Arguments

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

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

genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewSearchEqualFunc``.

noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewSearchEqualFunc_WithClosures``.

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

Wrap a `TreeViewSearchEqualFunc` into a `C_TreeViewSearchEqualFunc`.

## TreeViewSearchPositionFunc

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

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

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

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> TreeViewSearchPositionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

genClosure_TreeViewSearchPositionFunc :: MonadIO m => TreeViewSearchPositionFunc -> m (GClosure C_TreeViewSearchPositionFunc) Source #

Wrap the callback into a `GClosure`.

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

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

noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewSearchPositionFunc``.

noTreeViewSearchPositionFunc_WithClosures :: Maybe TreeViewSearchPositionFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `TreeViewSearchPositionFunc_WithClosures``.

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

Wrap a `TreeViewSearchPositionFunc` into a `C_TreeViewSearchPositionFunc`.

## WidgetClassAdjustBaselineAllocationFieldCallback

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

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

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

No description available in the introspection data.

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

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

genClosure_WidgetClassAdjustBaselineAllocationFieldCallback :: MonadIO m => WidgetClassAdjustBaselineAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineAllocationFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassAdjustBaselineAllocationFieldCallback :: C_WidgetClassAdjustBaselineAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassAdjustBaselineAllocationFieldCallback`.

noWidgetClassAdjustBaselineAllocationFieldCallback :: Maybe WidgetClassAdjustBaselineAllocationFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassAdjustBaselineAllocationFieldCallback``.

wrap_WidgetClassAdjustBaselineAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)) -> WidgetClassAdjustBaselineAllocationFieldCallback -> C_WidgetClassAdjustBaselineAllocationFieldCallback Source #

Wrap a `WidgetClassAdjustBaselineAllocationFieldCallback` into a `C_WidgetClassAdjustBaselineAllocationFieldCallback`.

## WidgetClassAdjustBaselineRequestFieldCallback

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

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

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

No description available in the introspection data.

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

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

genClosure_WidgetClassAdjustBaselineRequestFieldCallback :: MonadIO m => WidgetClassAdjustBaselineRequestFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineRequestFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassAdjustBaselineRequestFieldCallback :: C_WidgetClassAdjustBaselineRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassAdjustBaselineRequestFieldCallback`.

noWidgetClassAdjustBaselineRequestFieldCallback :: Maybe WidgetClassAdjustBaselineRequestFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassAdjustBaselineRequestFieldCallback``.

wrap_WidgetClassAdjustBaselineRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)) -> WidgetClassAdjustBaselineRequestFieldCallback -> C_WidgetClassAdjustBaselineRequestFieldCallback Source #

Wrap a `WidgetClassAdjustBaselineRequestFieldCallback` into a `C_WidgetClassAdjustBaselineRequestFieldCallback`.

## WidgetClassAdjustSizeAllocationFieldCallback

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

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

type WidgetClassAdjustSizeAllocationFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassAdjustSizeAllocationFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> a -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> m () Source #

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

genClosure_WidgetClassAdjustSizeAllocationFieldCallback :: MonadIO m => WidgetClassAdjustSizeAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustSizeAllocationFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassAdjustSizeAllocationFieldCallback :: C_WidgetClassAdjustSizeAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassAdjustSizeAllocationFieldCallback`.

noWidgetClassAdjustSizeAllocationFieldCallback :: Maybe WidgetClassAdjustSizeAllocationFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassAdjustSizeAllocationFieldCallback``.

wrap_WidgetClassAdjustSizeAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)) -> WidgetClassAdjustSizeAllocationFieldCallback -> C_WidgetClassAdjustSizeAllocationFieldCallback Source #

Wrap a `WidgetClassAdjustSizeAllocationFieldCallback` into a `C_WidgetClassAdjustSizeAllocationFieldCallback`.

## WidgetClassAdjustSizeRequestFieldCallback

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

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

type WidgetClassAdjustSizeRequestFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassAdjustSizeRequestFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> a -> Orientation -> Int32 -> Int32 -> m () Source #

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

genClosure_WidgetClassAdjustSizeRequestFieldCallback :: MonadIO m => WidgetClassAdjustSizeRequestFieldCallback -> m (GClosure C_WidgetClassAdjustSizeRequestFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassAdjustSizeRequestFieldCallback :: C_WidgetClassAdjustSizeRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassAdjustSizeRequestFieldCallback`.

noWidgetClassAdjustSizeRequestFieldCallback :: Maybe WidgetClassAdjustSizeRequestFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassAdjustSizeRequestFieldCallback``.

wrap_WidgetClassAdjustSizeRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)) -> WidgetClassAdjustSizeRequestFieldCallback -> C_WidgetClassAdjustSizeRequestFieldCallback Source #

Wrap a `WidgetClassAdjustSizeRequestFieldCallback` into a `C_WidgetClassAdjustSizeRequestFieldCallback`.

## WidgetClassButtonPressEventFieldCallback

type C_WidgetClassButtonPressEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt Source #

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

type WidgetClassButtonPressEventFieldCallback = Widget -> EventButton -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassButtonPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonPressEventFieldCallback -> a -> EventButton -> m Bool Source #

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

genClosure_WidgetClassButtonPressEventFieldCallback :: MonadIO m => WidgetClassButtonPressEventFieldCallback -> m (GClosure C_WidgetClassButtonPressEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassButtonPressEventFieldCallback :: C_WidgetClassButtonPressEventFieldCallback -> IO (FunPtr C_WidgetClassButtonPressEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassButtonPressEventFieldCallback`.

noWidgetClassButtonPressEventFieldCallback :: Maybe WidgetClassButtonPressEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassButtonPressEventFieldCallback``.

wrap_WidgetClassButtonPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)) -> WidgetClassButtonPressEventFieldCallback -> C_WidgetClassButtonPressEventFieldCallback Source #

Wrap a `WidgetClassButtonPressEventFieldCallback` into a `C_WidgetClassButtonPressEventFieldCallback`.

## WidgetClassButtonReleaseEventFieldCallback

type C_WidgetClassButtonReleaseEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt Source #

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

type WidgetClassButtonReleaseEventFieldCallback = Widget -> EventButton -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassButtonReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonReleaseEventFieldCallback -> a -> EventButton -> m Bool Source #

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

genClosure_WidgetClassButtonReleaseEventFieldCallback :: MonadIO m => WidgetClassButtonReleaseEventFieldCallback -> m (GClosure C_WidgetClassButtonReleaseEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassButtonReleaseEventFieldCallback :: C_WidgetClassButtonReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassButtonReleaseEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassButtonReleaseEventFieldCallback`.

noWidgetClassButtonReleaseEventFieldCallback :: Maybe WidgetClassButtonReleaseEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassButtonReleaseEventFieldCallback``.

wrap_WidgetClassButtonReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)) -> WidgetClassButtonReleaseEventFieldCallback -> C_WidgetClassButtonReleaseEventFieldCallback Source #

Wrap a `WidgetClassButtonReleaseEventFieldCallback` into a `C_WidgetClassButtonReleaseEventFieldCallback`.

## WidgetClassCanActivateAccelFieldCallback

type C_WidgetClassCanActivateAccelFieldCallback = Ptr Widget -> Word32 -> IO CInt Source #

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

type WidgetClassCanActivateAccelFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget`
-> Word32 | `signalId`: the ID of a signal installed on `widget`
-> IO Bool | Returns: `True` if the accelerator can be activated.

No description available in the introspection data.

dynamic_WidgetClassCanActivateAccelFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassCanActivateAccelFieldCallback |
-> a | `widget`: a `Widget`
-> Word32 | `signalId`: the ID of a signal installed on `widget`
-> m Bool | Returns: `True` if the accelerator can be activated.

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

genClosure_WidgetClassCanActivateAccelFieldCallback :: MonadIO m => WidgetClassCanActivateAccelFieldCallback -> m (GClosure C_WidgetClassCanActivateAccelFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassCanActivateAccelFieldCallback :: C_WidgetClassCanActivateAccelFieldCallback -> IO (FunPtr C_WidgetClassCanActivateAccelFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassCanActivateAccelFieldCallback`.

noWidgetClassCanActivateAccelFieldCallback :: Maybe WidgetClassCanActivateAccelFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassCanActivateAccelFieldCallback``.

wrap_WidgetClassCanActivateAccelFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)) -> WidgetClassCanActivateAccelFieldCallback -> C_WidgetClassCanActivateAccelFieldCallback Source #

Wrap a `WidgetClassCanActivateAccelFieldCallback` into a `C_WidgetClassCanActivateAccelFieldCallback`.

## WidgetClassChildNotifyFieldCallback

type C_WidgetClassChildNotifyFieldCallback = Ptr Widget -> Ptr GParamSpec -> IO () Source #

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

type WidgetClassChildNotifyFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget`
-> GParamSpec | `childProperty`: the name of a child property installed on the class of `widget`’s parent
-> IO () |

No description available in the introspection data.

dynamic_WidgetClassChildNotifyFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassChildNotifyFieldCallback |
-> a | `widget`: a `Widget`
-> GParamSpec | `childProperty`: the name of a child property installed on the class of `widget`’s parent
-> m () |

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

genClosure_WidgetClassChildNotifyFieldCallback :: MonadIO m => WidgetClassChildNotifyFieldCallback -> m (GClosure C_WidgetClassChildNotifyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassChildNotifyFieldCallback :: C_WidgetClassChildNotifyFieldCallback -> IO (FunPtr C_WidgetClassChildNotifyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassChildNotifyFieldCallback`.

noWidgetClassChildNotifyFieldCallback :: Maybe WidgetClassChildNotifyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassChildNotifyFieldCallback``.

wrap_WidgetClassChildNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassChildNotifyFieldCallback)) -> WidgetClassChildNotifyFieldCallback -> C_WidgetClassChildNotifyFieldCallback Source #

Wrap a `WidgetClassChildNotifyFieldCallback` into a `C_WidgetClassChildNotifyFieldCallback`.

## WidgetClassCompositedChangedFieldCallback

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

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

type WidgetClassCompositedChangedFieldCallback = Widget -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassCompositedChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCompositedChangedFieldCallback -> a -> m () Source #

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

genClosure_WidgetClassCompositedChangedFieldCallback :: MonadIO m => WidgetClassCompositedChangedFieldCallback -> m (GClosure C_WidgetClassCompositedChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassCompositedChangedFieldCallback :: C_WidgetClassCompositedChangedFieldCallback -> IO (FunPtr C_WidgetClassCompositedChangedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassCompositedChangedFieldCallback`.

noWidgetClassCompositedChangedFieldCallback :: Maybe WidgetClassCompositedChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassCompositedChangedFieldCallback``.

wrap_WidgetClassCompositedChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCompositedChangedFieldCallback)) -> WidgetClassCompositedChangedFieldCallback -> C_WidgetClassCompositedChangedFieldCallback Source #

Wrap a `WidgetClassCompositedChangedFieldCallback` into a `C_WidgetClassCompositedChangedFieldCallback`.

## WidgetClassComputeExpandFieldCallback

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

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

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

No description available in the introspection data.

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassComputeExpandFieldCallback``.

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

Wrap a `WidgetClassComputeExpandFieldCallback` into a `C_WidgetClassComputeExpandFieldCallback`.

## WidgetClassConfigureEventFieldCallback

type C_WidgetClassConfigureEventFieldCallback = Ptr Widget -> Ptr EventConfigure -> IO CInt Source #

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

type WidgetClassConfigureEventFieldCallback = Widget -> EventConfigure -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassConfigureEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassConfigureEventFieldCallback -> a -> EventConfigure -> m Bool Source #

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

genClosure_WidgetClassConfigureEventFieldCallback :: MonadIO m => WidgetClassConfigureEventFieldCallback -> m (GClosure C_WidgetClassConfigureEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassConfigureEventFieldCallback :: C_WidgetClassConfigureEventFieldCallback -> IO (FunPtr C_WidgetClassConfigureEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassConfigureEventFieldCallback`.

noWidgetClassConfigureEventFieldCallback :: Maybe WidgetClassConfigureEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassConfigureEventFieldCallback``.

wrap_WidgetClassConfigureEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassConfigureEventFieldCallback)) -> WidgetClassConfigureEventFieldCallback -> C_WidgetClassConfigureEventFieldCallback Source #

Wrap a `WidgetClassConfigureEventFieldCallback` into a `C_WidgetClassConfigureEventFieldCallback`.

## WidgetClassDamageEventFieldCallback

type C_WidgetClassDamageEventFieldCallback = Ptr Widget -> Ptr EventExpose -> IO CInt Source #

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

type WidgetClassDamageEventFieldCallback = Widget -> EventExpose -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassDamageEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDamageEventFieldCallback -> a -> EventExpose -> m Bool Source #

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

genClosure_WidgetClassDamageEventFieldCallback :: MonadIO m => WidgetClassDamageEventFieldCallback -> m (GClosure C_WidgetClassDamageEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDamageEventFieldCallback :: C_WidgetClassDamageEventFieldCallback -> IO (FunPtr C_WidgetClassDamageEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDamageEventFieldCallback`.

noWidgetClassDamageEventFieldCallback :: Maybe WidgetClassDamageEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDamageEventFieldCallback``.

wrap_WidgetClassDamageEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDamageEventFieldCallback)) -> WidgetClassDamageEventFieldCallback -> C_WidgetClassDamageEventFieldCallback Source #

Wrap a `WidgetClassDamageEventFieldCallback` into a `C_WidgetClassDamageEventFieldCallback`.

## WidgetClassDeleteEventFieldCallback

type C_WidgetClassDeleteEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt Source #

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

type WidgetClassDeleteEventFieldCallback = Widget -> EventAny -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassDeleteEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDeleteEventFieldCallback -> a -> EventAny -> m Bool Source #

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

genClosure_WidgetClassDeleteEventFieldCallback :: MonadIO m => WidgetClassDeleteEventFieldCallback -> m (GClosure C_WidgetClassDeleteEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDeleteEventFieldCallback :: C_WidgetClassDeleteEventFieldCallback -> IO (FunPtr C_WidgetClassDeleteEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDeleteEventFieldCallback`.

noWidgetClassDeleteEventFieldCallback :: Maybe WidgetClassDeleteEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDeleteEventFieldCallback``.

wrap_WidgetClassDeleteEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)) -> WidgetClassDeleteEventFieldCallback -> C_WidgetClassDeleteEventFieldCallback Source #

Wrap a `WidgetClassDeleteEventFieldCallback` into a `C_WidgetClassDeleteEventFieldCallback`.

## WidgetClassDestroyEventFieldCallback

type C_WidgetClassDestroyEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt Source #

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

type WidgetClassDestroyEventFieldCallback = Widget -> EventAny -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassDestroyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDestroyEventFieldCallback -> a -> EventAny -> m Bool Source #

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

genClosure_WidgetClassDestroyEventFieldCallback :: MonadIO m => WidgetClassDestroyEventFieldCallback -> m (GClosure C_WidgetClassDestroyEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDestroyEventFieldCallback :: C_WidgetClassDestroyEventFieldCallback -> IO (FunPtr C_WidgetClassDestroyEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDestroyEventFieldCallback`.

noWidgetClassDestroyEventFieldCallback :: Maybe WidgetClassDestroyEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDestroyEventFieldCallback``.

wrap_WidgetClassDestroyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyEventFieldCallback)) -> WidgetClassDestroyEventFieldCallback -> C_WidgetClassDestroyEventFieldCallback Source #

Wrap a `WidgetClassDestroyEventFieldCallback` into a `C_WidgetClassDestroyEventFieldCallback`.

## WidgetClassDestroyFieldCallback

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

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

type WidgetClassDestroyFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassDestroyFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassDestroyFieldCallback |
-> a | `widget`: a `Widget`
-> m () |

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

genClosure_WidgetClassDestroyFieldCallback :: MonadIO m => WidgetClassDestroyFieldCallback -> m (GClosure C_WidgetClassDestroyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDestroyFieldCallback :: C_WidgetClassDestroyFieldCallback -> IO (FunPtr C_WidgetClassDestroyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDestroyFieldCallback`.

noWidgetClassDestroyFieldCallback :: Maybe WidgetClassDestroyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDestroyFieldCallback``.

wrap_WidgetClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyFieldCallback)) -> WidgetClassDestroyFieldCallback -> C_WidgetClassDestroyFieldCallback Source #

Wrap a `WidgetClassDestroyFieldCallback` into a `C_WidgetClassDestroyFieldCallback`.

## WidgetClassDirectionChangedFieldCallback

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

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

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

No description available in the introspection data.

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDirectionChangedFieldCallback``.

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

Wrap a `WidgetClassDirectionChangedFieldCallback` into a `C_WidgetClassDirectionChangedFieldCallback`.

## WidgetClassDispatchChildPropertiesChangedFieldCallback

type C_WidgetClassDispatchChildPropertiesChangedFieldCallback = Ptr Widget -> Word32 -> Ptr GParamSpec -> IO () Source #

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

type WidgetClassDispatchChildPropertiesChangedFieldCallback = Widget -> Word32 -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDispatchChildPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m () Source #

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

genClosure_WidgetClassDispatchChildPropertiesChangedFieldCallback :: MonadIO m => WidgetClassDispatchChildPropertiesChangedFieldCallback -> m (GClosure C_WidgetClassDispatchChildPropertiesChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDispatchChildPropertiesChangedFieldCallback :: C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> IO (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDispatchChildPropertiesChangedFieldCallback`.

noWidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDispatchChildPropertiesChangedFieldCallback``.

wrap_WidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)) -> WidgetClassDispatchChildPropertiesChangedFieldCallback -> C_WidgetClassDispatchChildPropertiesChangedFieldCallback Source #

Wrap a `WidgetClassDispatchChildPropertiesChangedFieldCallback` into a `C_WidgetClassDispatchChildPropertiesChangedFieldCallback`.

## WidgetClassDragBeginFieldCallback

type C_WidgetClassDragBeginFieldCallback = Ptr Widget -> Ptr DragContext -> IO () Source #

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

type WidgetClassDragBeginFieldCallback = Widget -> DragContext -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDragBeginFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m () Source #

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

genClosure_WidgetClassDragBeginFieldCallback :: MonadIO m => WidgetClassDragBeginFieldCallback -> m (GClosure C_WidgetClassDragBeginFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragBeginFieldCallback :: C_WidgetClassDragBeginFieldCallback -> IO (FunPtr C_WidgetClassDragBeginFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragBeginFieldCallback`.

noWidgetClassDragBeginFieldCallback :: Maybe WidgetClassDragBeginFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragBeginFieldCallback``.

wrap_WidgetClassDragBeginFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)) -> WidgetClassDragBeginFieldCallback -> C_WidgetClassDragBeginFieldCallback Source #

Wrap a `WidgetClassDragBeginFieldCallback` into a `C_WidgetClassDragBeginFieldCallback`.

## WidgetClassDragDataDeleteFieldCallback

type C_WidgetClassDragDataDeleteFieldCallback = Ptr Widget -> Ptr DragContext -> IO () Source #

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

type WidgetClassDragDataDeleteFieldCallback = Widget -> DragContext -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDragDataDeleteFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataDeleteFieldCallback -> a -> b -> m () Source #

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

genClosure_WidgetClassDragDataDeleteFieldCallback :: MonadIO m => WidgetClassDragDataDeleteFieldCallback -> m (GClosure C_WidgetClassDragDataDeleteFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragDataDeleteFieldCallback :: C_WidgetClassDragDataDeleteFieldCallback -> IO (FunPtr C_WidgetClassDragDataDeleteFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragDataDeleteFieldCallback`.

noWidgetClassDragDataDeleteFieldCallback :: Maybe WidgetClassDragDataDeleteFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragDataDeleteFieldCallback``.

wrap_WidgetClassDragDataDeleteFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataDeleteFieldCallback)) -> WidgetClassDragDataDeleteFieldCallback -> C_WidgetClassDragDataDeleteFieldCallback Source #

Wrap a `WidgetClassDragDataDeleteFieldCallback` into a `C_WidgetClassDragDataDeleteFieldCallback`.

## WidgetClassDragDataGetFieldCallback

type C_WidgetClassDragDataGetFieldCallback = Ptr Widget -> Ptr DragContext -> Ptr SelectionData -> Word32 -> Word32 -> IO () Source #

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

type WidgetClassDragDataGetFieldCallback = Widget -> DragContext -> SelectionData -> Word32 -> Word32 -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDragDataGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataGetFieldCallback -> a -> b -> SelectionData -> Word32 -> Word32 -> m () Source #

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

genClosure_WidgetClassDragDataGetFieldCallback :: MonadIO m => WidgetClassDragDataGetFieldCallback -> m (GClosure C_WidgetClassDragDataGetFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragDataGetFieldCallback :: C_WidgetClassDragDataGetFieldCallback -> IO (FunPtr C_WidgetClassDragDataGetFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragDataGetFieldCallback`.

noWidgetClassDragDataGetFieldCallback :: Maybe WidgetClassDragDataGetFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragDataGetFieldCallback``.

wrap_WidgetClassDragDataGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)) -> WidgetClassDragDataGetFieldCallback -> C_WidgetClassDragDataGetFieldCallback Source #

Wrap a `WidgetClassDragDataGetFieldCallback` into a `C_WidgetClassDragDataGetFieldCallback`.

## WidgetClassDragDataReceivedFieldCallback

type C_WidgetClassDragDataReceivedFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Ptr SelectionData -> Word32 -> Word32 -> IO () Source #

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

type WidgetClassDragDataReceivedFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDragDataReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataReceivedFieldCallback -> a -> b -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> m () Source #

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

genClosure_WidgetClassDragDataReceivedFieldCallback :: MonadIO m => WidgetClassDragDataReceivedFieldCallback -> m (GClosure C_WidgetClassDragDataReceivedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragDataReceivedFieldCallback :: C_WidgetClassDragDataReceivedFieldCallback -> IO (FunPtr C_WidgetClassDragDataReceivedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragDataReceivedFieldCallback`.

noWidgetClassDragDataReceivedFieldCallback :: Maybe WidgetClassDragDataReceivedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragDataReceivedFieldCallback``.

wrap_WidgetClassDragDataReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)) -> WidgetClassDragDataReceivedFieldCallback -> C_WidgetClassDragDataReceivedFieldCallback Source #

Wrap a `WidgetClassDragDataReceivedFieldCallback` into a `C_WidgetClassDragDataReceivedFieldCallback`.

## WidgetClassDragDropFieldCallback

type C_WidgetClassDragDropFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt Source #

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

type WidgetClassDragDropFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassDragDropFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDropFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool Source #

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

genClosure_WidgetClassDragDropFieldCallback :: MonadIO m => WidgetClassDragDropFieldCallback -> m (GClosure C_WidgetClassDragDropFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragDropFieldCallback :: C_WidgetClassDragDropFieldCallback -> IO (FunPtr C_WidgetClassDragDropFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragDropFieldCallback`.

noWidgetClassDragDropFieldCallback :: Maybe WidgetClassDragDropFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragDropFieldCallback``.

wrap_WidgetClassDragDropFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDropFieldCallback)) -> WidgetClassDragDropFieldCallback -> C_WidgetClassDragDropFieldCallback Source #

Wrap a `WidgetClassDragDropFieldCallback` into a `C_WidgetClassDragDropFieldCallback`.

## WidgetClassDragEndFieldCallback

type C_WidgetClassDragEndFieldCallback = Ptr Widget -> Ptr DragContext -> IO () Source #

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

type WidgetClassDragEndFieldCallback = Widget -> DragContext -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDragEndFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragEndFieldCallback -> a -> b -> m () Source #

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

genClosure_WidgetClassDragEndFieldCallback :: MonadIO m => WidgetClassDragEndFieldCallback -> m (GClosure C_WidgetClassDragEndFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragEndFieldCallback :: C_WidgetClassDragEndFieldCallback -> IO (FunPtr C_WidgetClassDragEndFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragEndFieldCallback`.

noWidgetClassDragEndFieldCallback :: Maybe WidgetClassDragEndFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragEndFieldCallback``.

wrap_WidgetClassDragEndFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragEndFieldCallback)) -> WidgetClassDragEndFieldCallback -> C_WidgetClassDragEndFieldCallback Source #

Wrap a `WidgetClassDragEndFieldCallback` into a `C_WidgetClassDragEndFieldCallback`.

## WidgetClassDragFailedFieldCallback

type C_WidgetClassDragFailedFieldCallback = Ptr Widget -> Ptr DragContext -> CUInt -> IO CInt Source #

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

type WidgetClassDragFailedFieldCallback = Widget -> DragContext -> DragResult -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassDragFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragFailedFieldCallback -> a -> b -> DragResult -> m Bool Source #

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

genClosure_WidgetClassDragFailedFieldCallback :: MonadIO m => WidgetClassDragFailedFieldCallback -> m (GClosure C_WidgetClassDragFailedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragFailedFieldCallback :: C_WidgetClassDragFailedFieldCallback -> IO (FunPtr C_WidgetClassDragFailedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragFailedFieldCallback`.

noWidgetClassDragFailedFieldCallback :: Maybe WidgetClassDragFailedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragFailedFieldCallback``.

wrap_WidgetClassDragFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)) -> WidgetClassDragFailedFieldCallback -> C_WidgetClassDragFailedFieldCallback Source #

Wrap a `WidgetClassDragFailedFieldCallback` into a `C_WidgetClassDragFailedFieldCallback`.

## WidgetClassDragLeaveFieldCallback

type C_WidgetClassDragLeaveFieldCallback = Ptr Widget -> Ptr DragContext -> Word32 -> IO () Source #

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

type WidgetClassDragLeaveFieldCallback = Widget -> DragContext -> Word32 -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassDragLeaveFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragLeaveFieldCallback -> a -> b -> Word32 -> m () Source #

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

genClosure_WidgetClassDragLeaveFieldCallback :: MonadIO m => WidgetClassDragLeaveFieldCallback -> m (GClosure C_WidgetClassDragLeaveFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragLeaveFieldCallback :: C_WidgetClassDragLeaveFieldCallback -> IO (FunPtr C_WidgetClassDragLeaveFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragLeaveFieldCallback`.

noWidgetClassDragLeaveFieldCallback :: Maybe WidgetClassDragLeaveFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragLeaveFieldCallback``.

wrap_WidgetClassDragLeaveFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)) -> WidgetClassDragLeaveFieldCallback -> C_WidgetClassDragLeaveFieldCallback Source #

Wrap a `WidgetClassDragLeaveFieldCallback` into a `C_WidgetClassDragLeaveFieldCallback`.

## WidgetClassDragMotionFieldCallback

type C_WidgetClassDragMotionFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt Source #

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

type WidgetClassDragMotionFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassDragMotionFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragMotionFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool Source #

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

genClosure_WidgetClassDragMotionFieldCallback :: MonadIO m => WidgetClassDragMotionFieldCallback -> m (GClosure C_WidgetClassDragMotionFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDragMotionFieldCallback :: C_WidgetClassDragMotionFieldCallback -> IO (FunPtr C_WidgetClassDragMotionFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDragMotionFieldCallback`.

noWidgetClassDragMotionFieldCallback :: Maybe WidgetClassDragMotionFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDragMotionFieldCallback``.

wrap_WidgetClassDragMotionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)) -> WidgetClassDragMotionFieldCallback -> C_WidgetClassDragMotionFieldCallback Source #

Wrap a `WidgetClassDragMotionFieldCallback` into a `C_WidgetClassDragMotionFieldCallback`.

## WidgetClassDrawFieldCallback

type C_WidgetClassDrawFieldCallback = Ptr Widget -> Ptr Context -> IO CInt Source #

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

type WidgetClassDrawFieldCallback = Widget -> Context -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassDrawFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDrawFieldCallback -> a -> Context -> m Bool Source #

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

genClosure_WidgetClassDrawFieldCallback :: MonadIO m => WidgetClassDrawFieldCallback -> m (GClosure C_WidgetClassDrawFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassDrawFieldCallback :: C_WidgetClassDrawFieldCallback -> IO (FunPtr C_WidgetClassDrawFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassDrawFieldCallback`.

noWidgetClassDrawFieldCallback :: Maybe WidgetClassDrawFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassDrawFieldCallback``.

wrap_WidgetClassDrawFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDrawFieldCallback)) -> WidgetClassDrawFieldCallback -> C_WidgetClassDrawFieldCallback Source #

Wrap a `WidgetClassDrawFieldCallback` into a `C_WidgetClassDrawFieldCallback`.

## WidgetClassEnterNotifyEventFieldCallback

type C_WidgetClassEnterNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt Source #

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

type WidgetClassEnterNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassEnterNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> a -> EventCrossing -> m Bool Source #

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

genClosure_WidgetClassEnterNotifyEventFieldCallback :: MonadIO m => WidgetClassEnterNotifyEventFieldCallback -> m (GClosure C_WidgetClassEnterNotifyEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassEnterNotifyEventFieldCallback :: C_WidgetClassEnterNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassEnterNotifyEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassEnterNotifyEventFieldCallback`.

noWidgetClassEnterNotifyEventFieldCallback :: Maybe WidgetClassEnterNotifyEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassEnterNotifyEventFieldCallback``.

wrap_WidgetClassEnterNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)) -> WidgetClassEnterNotifyEventFieldCallback -> C_WidgetClassEnterNotifyEventFieldCallback Source #

Wrap a `WidgetClassEnterNotifyEventFieldCallback` into a `C_WidgetClassEnterNotifyEventFieldCallback`.

## WidgetClassEventFieldCallback

type C_WidgetClassEventFieldCallback = Ptr Widget -> Ptr Event -> IO CInt Source #

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

type WidgetClassEventFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget`
-> Event | `event`: a `Event`
-> IO Bool | Returns: return from the event signal emission (`True` if the event was handled)

No description available in the introspection data.

dynamic_WidgetClassEventFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassEventFieldCallback |
-> a | `widget`: a `Widget`
-> Event | `event`: a `Event`
-> m Bool | Returns: return from the event signal emission (`True` if the event was handled)

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

genClosure_WidgetClassEventFieldCallback :: MonadIO m => WidgetClassEventFieldCallback -> m (GClosure C_WidgetClassEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassEventFieldCallback :: C_WidgetClassEventFieldCallback -> IO (FunPtr C_WidgetClassEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassEventFieldCallback`.

noWidgetClassEventFieldCallback :: Maybe WidgetClassEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassEventFieldCallback``.

wrap_WidgetClassEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEventFieldCallback)) -> WidgetClassEventFieldCallback -> C_WidgetClassEventFieldCallback Source #

Wrap a `WidgetClassEventFieldCallback` into a `C_WidgetClassEventFieldCallback`.

## WidgetClassFocusFieldCallback

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

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

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

No description available in the introspection data.

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassFocusFieldCallback``.

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

Wrap a `WidgetClassFocusFieldCallback` into a `C_WidgetClassFocusFieldCallback`.

## WidgetClassFocusInEventFieldCallback

type C_WidgetClassFocusInEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt Source #

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

type WidgetClassFocusInEventFieldCallback = Widget -> EventFocus -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassFocusInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusInEventFieldCallback -> a -> EventFocus -> m Bool Source #

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

genClosure_WidgetClassFocusInEventFieldCallback :: MonadIO m => WidgetClassFocusInEventFieldCallback -> m (GClosure C_WidgetClassFocusInEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassFocusInEventFieldCallback :: C_WidgetClassFocusInEventFieldCallback -> IO (FunPtr C_WidgetClassFocusInEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassFocusInEventFieldCallback`.

noWidgetClassFocusInEventFieldCallback :: Maybe WidgetClassFocusInEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassFocusInEventFieldCallback``.

wrap_WidgetClassFocusInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)) -> WidgetClassFocusInEventFieldCallback -> C_WidgetClassFocusInEventFieldCallback Source #

Wrap a `WidgetClassFocusInEventFieldCallback` into a `C_WidgetClassFocusInEventFieldCallback`.

## WidgetClassFocusOutEventFieldCallback

type C_WidgetClassFocusOutEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt Source #

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

type WidgetClassFocusOutEventFieldCallback = Widget -> EventFocus -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassFocusOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusOutEventFieldCallback -> a -> EventFocus -> m Bool Source #

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

genClosure_WidgetClassFocusOutEventFieldCallback :: MonadIO m => WidgetClassFocusOutEventFieldCallback -> m (GClosure C_WidgetClassFocusOutEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassFocusOutEventFieldCallback :: C_WidgetClassFocusOutEventFieldCallback -> IO (FunPtr C_WidgetClassFocusOutEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassFocusOutEventFieldCallback`.

noWidgetClassFocusOutEventFieldCallback :: Maybe WidgetClassFocusOutEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassFocusOutEventFieldCallback``.

wrap_WidgetClassFocusOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusOutEventFieldCallback)) -> WidgetClassFocusOutEventFieldCallback -> C_WidgetClassFocusOutEventFieldCallback Source #

Wrap a `WidgetClassFocusOutEventFieldCallback` into a `C_WidgetClassFocusOutEventFieldCallback`.

## WidgetClassGetAccessibleFieldCallback

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

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

type WidgetClassGetAccessibleFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget`
-> IO Object | Returns: the `Object` associated with `widget`

No description available in the introspection data.

dynamic_WidgetClassGetAccessibleFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGetAccessibleFieldCallback |
-> a | `widget`: a `Widget`
-> m Object | Returns: the `Object` associated with `widget`

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

genClosure_WidgetClassGetAccessibleFieldCallback :: MonadIO m => WidgetClassGetAccessibleFieldCallback -> m (GClosure C_WidgetClassGetAccessibleFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGetAccessibleFieldCallback :: C_WidgetClassGetAccessibleFieldCallback -> IO (FunPtr C_WidgetClassGetAccessibleFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGetAccessibleFieldCallback`.

noWidgetClassGetAccessibleFieldCallback :: Maybe WidgetClassGetAccessibleFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGetAccessibleFieldCallback``.

wrap_WidgetClassGetAccessibleFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)) -> WidgetClassGetAccessibleFieldCallback -> C_WidgetClassGetAccessibleFieldCallback Source #

Wrap a `WidgetClassGetAccessibleFieldCallback` into a `C_WidgetClassGetAccessibleFieldCallback`.

## WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

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

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

type WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget` instance
-> Int32 | `width`: the width which is available for allocation, or -1 if none
-> IO (Int32, Int32, Int32, Int32) |

No description available in the introspection data.

dynamic_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback |
-> a | `widget`: a `Widget` instance
-> Int32 | `width`: the width which is available for allocation, or -1 if none
-> m (Int32, Int32, Int32, Int32) |

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

genClosure_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback`.

noWidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback``.

wrap_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)) -> WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback Source #

Wrap a `WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback` into a `C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback`.

## WidgetClassGetPreferredHeightFieldCallback

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

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

type WidgetClassGetPreferredHeightFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget` instance
-> IO (Int32, Int32) |

No description available in the introspection data.

dynamic_WidgetClassGetPreferredHeightFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGetPreferredHeightFieldCallback |
-> a | `widget`: a `Widget` instance
-> m (Int32, Int32) |

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

genClosure_WidgetClassGetPreferredHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGetPreferredHeightFieldCallback :: C_WidgetClassGetPreferredHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGetPreferredHeightFieldCallback`.

noWidgetClassGetPreferredHeightFieldCallback :: Maybe WidgetClassGetPreferredHeightFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGetPreferredHeightFieldCallback``.

wrap_WidgetClassGetPreferredHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)) -> WidgetClassGetPreferredHeightFieldCallback -> C_WidgetClassGetPreferredHeightFieldCallback Source #

Wrap a `WidgetClassGetPreferredHeightFieldCallback` into a `C_WidgetClassGetPreferredHeightFieldCallback`.

## WidgetClassGetPreferredHeightForWidthFieldCallback

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

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

type WidgetClassGetPreferredHeightForWidthFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget` instance
-> Int32 | `width`: the width which is available for allocation
-> IO (Int32, Int32) |

No description available in the introspection data.

dynamic_WidgetClassGetPreferredHeightForWidthFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback |
-> a | `widget`: a `Widget` instance
-> Int32 | `width`: the width which is available for allocation
-> m (Int32, Int32) |

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

genClosure_WidgetClassGetPreferredHeightForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightForWidthFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGetPreferredHeightForWidthFieldCallback :: C_WidgetClassGetPreferredHeightForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGetPreferredHeightForWidthFieldCallback`.

noWidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightForWidthFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGetPreferredHeightForWidthFieldCallback``.

wrap_WidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)) -> WidgetClassGetPreferredHeightForWidthFieldCallback -> C_WidgetClassGetPreferredHeightForWidthFieldCallback Source #

Wrap a `WidgetClassGetPreferredHeightForWidthFieldCallback` into a `C_WidgetClassGetPreferredHeightForWidthFieldCallback`.

## WidgetClassGetPreferredWidthFieldCallback

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

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

type WidgetClassGetPreferredWidthFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget` instance
-> IO (Int32, Int32) |

No description available in the introspection data.

dynamic_WidgetClassGetPreferredWidthFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGetPreferredWidthFieldCallback |
-> a | `widget`: a `Widget` instance
-> m (Int32, Int32) |

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

genClosure_WidgetClassGetPreferredWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGetPreferredWidthFieldCallback :: C_WidgetClassGetPreferredWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGetPreferredWidthFieldCallback`.

noWidgetClassGetPreferredWidthFieldCallback :: Maybe WidgetClassGetPreferredWidthFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGetPreferredWidthFieldCallback``.

wrap_WidgetClassGetPreferredWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)) -> WidgetClassGetPreferredWidthFieldCallback -> C_WidgetClassGetPreferredWidthFieldCallback Source #

Wrap a `WidgetClassGetPreferredWidthFieldCallback` into a `C_WidgetClassGetPreferredWidthFieldCallback`.

## WidgetClassGetPreferredWidthForHeightFieldCallback

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

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

type WidgetClassGetPreferredWidthForHeightFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget` instance
-> Int32 | `height`: the height which is available for allocation
-> IO (Int32, Int32) |

No description available in the introspection data.

dynamic_WidgetClassGetPreferredWidthForHeightFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback |
-> a | `widget`: a `Widget` instance
-> Int32 | `height`: the height which is available for allocation
-> m (Int32, Int32) |

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

genClosure_WidgetClassGetPreferredWidthForHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthForHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthForHeightFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGetPreferredWidthForHeightFieldCallback :: C_WidgetClassGetPreferredWidthForHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGetPreferredWidthForHeightFieldCallback`.

noWidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe WidgetClassGetPreferredWidthForHeightFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGetPreferredWidthForHeightFieldCallback``.

wrap_WidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)) -> WidgetClassGetPreferredWidthForHeightFieldCallback -> C_WidgetClassGetPreferredWidthForHeightFieldCallback Source #

Wrap a `WidgetClassGetPreferredWidthForHeightFieldCallback` into a `C_WidgetClassGetPreferredWidthForHeightFieldCallback`.

## WidgetClassGetRequestModeFieldCallback

type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt Source #

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

type WidgetClassGetRequestModeFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget` instance
-> IO SizeRequestMode | Returns: The `SizeRequestMode` preferred by `widget`.

No description available in the introspection data.

dynamic_WidgetClassGetRequestModeFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGetRequestModeFieldCallback |
-> a | `widget`: a `Widget` instance
-> m SizeRequestMode | Returns: The `SizeRequestMode` preferred by `widget`.

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

genClosure_WidgetClassGetRequestModeFieldCallback :: MonadIO m => WidgetClassGetRequestModeFieldCallback -> m (GClosure C_WidgetClassGetRequestModeFieldCallback) Source #

Wrap the callback into a `GClosure`.

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

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

noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGetRequestModeFieldCallback``.

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

Wrap a `WidgetClassGetRequestModeFieldCallback` into a `C_WidgetClassGetRequestModeFieldCallback`.

## WidgetClassGrabBrokenEventFieldCallback

type C_WidgetClassGrabBrokenEventFieldCallback = Ptr Widget -> Ptr EventGrabBroken -> IO CInt Source #

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

type WidgetClassGrabBrokenEventFieldCallback = Widget -> EventGrabBroken -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassGrabBrokenEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> a -> EventGrabBroken -> m Bool Source #

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

genClosure_WidgetClassGrabBrokenEventFieldCallback :: MonadIO m => WidgetClassGrabBrokenEventFieldCallback -> m (GClosure C_WidgetClassGrabBrokenEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGrabBrokenEventFieldCallback :: C_WidgetClassGrabBrokenEventFieldCallback -> IO (FunPtr C_WidgetClassGrabBrokenEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGrabBrokenEventFieldCallback`.

noWidgetClassGrabBrokenEventFieldCallback :: Maybe WidgetClassGrabBrokenEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGrabBrokenEventFieldCallback``.

wrap_WidgetClassGrabBrokenEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)) -> WidgetClassGrabBrokenEventFieldCallback -> C_WidgetClassGrabBrokenEventFieldCallback Source #

Wrap a `WidgetClassGrabBrokenEventFieldCallback` into a `C_WidgetClassGrabBrokenEventFieldCallback`.

## WidgetClassGrabFocusFieldCallback

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

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

type WidgetClassGrabFocusFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassGrabFocusFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassGrabFocusFieldCallback |
-> a | `widget`: a `Widget`
-> m () |

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGrabFocusFieldCallback``.

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

Wrap a `WidgetClassGrabFocusFieldCallback` into a `C_WidgetClassGrabFocusFieldCallback`.

## WidgetClassGrabNotifyFieldCallback

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

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

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

No description available in the introspection data.

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

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

genClosure_WidgetClassGrabNotifyFieldCallback :: MonadIO m => WidgetClassGrabNotifyFieldCallback -> m (GClosure C_WidgetClassGrabNotifyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassGrabNotifyFieldCallback :: C_WidgetClassGrabNotifyFieldCallback -> IO (FunPtr C_WidgetClassGrabNotifyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassGrabNotifyFieldCallback`.

noWidgetClassGrabNotifyFieldCallback :: Maybe WidgetClassGrabNotifyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassGrabNotifyFieldCallback``.

wrap_WidgetClassGrabNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)) -> WidgetClassGrabNotifyFieldCallback -> C_WidgetClassGrabNotifyFieldCallback Source #

Wrap a `WidgetClassGrabNotifyFieldCallback` into a `C_WidgetClassGrabNotifyFieldCallback`.

## WidgetClassHideFieldCallback

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

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

type WidgetClassHideFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassHideFieldCallback Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassHideFieldCallback``.

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

Wrap a `WidgetClassHideFieldCallback` into a `C_WidgetClassHideFieldCallback`.

## WidgetClassHierarchyChangedFieldCallback

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

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

type WidgetClassHierarchyChangedFieldCallback = Widget -> Widget -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassHierarchyChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassHierarchyChangedFieldCallback -> a -> b -> m () Source #

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

genClosure_WidgetClassHierarchyChangedFieldCallback :: MonadIO m => WidgetClassHierarchyChangedFieldCallback -> m (GClosure C_WidgetClassHierarchyChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassHierarchyChangedFieldCallback :: C_WidgetClassHierarchyChangedFieldCallback -> IO (FunPtr C_WidgetClassHierarchyChangedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassHierarchyChangedFieldCallback`.

noWidgetClassHierarchyChangedFieldCallback :: Maybe WidgetClassHierarchyChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassHierarchyChangedFieldCallback``.

wrap_WidgetClassHierarchyChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHierarchyChangedFieldCallback)) -> WidgetClassHierarchyChangedFieldCallback -> C_WidgetClassHierarchyChangedFieldCallback Source #

Wrap a `WidgetClassHierarchyChangedFieldCallback` into a `C_WidgetClassHierarchyChangedFieldCallback`.

## WidgetClassKeyPressEventFieldCallback

type C_WidgetClassKeyPressEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt Source #

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

type WidgetClassKeyPressEventFieldCallback = Widget -> EventKey -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassKeyPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyPressEventFieldCallback -> a -> EventKey -> m Bool Source #

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

genClosure_WidgetClassKeyPressEventFieldCallback :: MonadIO m => WidgetClassKeyPressEventFieldCallback -> m (GClosure C_WidgetClassKeyPressEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassKeyPressEventFieldCallback :: C_WidgetClassKeyPressEventFieldCallback -> IO (FunPtr C_WidgetClassKeyPressEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassKeyPressEventFieldCallback`.

noWidgetClassKeyPressEventFieldCallback :: Maybe WidgetClassKeyPressEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassKeyPressEventFieldCallback``.

wrap_WidgetClassKeyPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)) -> WidgetClassKeyPressEventFieldCallback -> C_WidgetClassKeyPressEventFieldCallback Source #

Wrap a `WidgetClassKeyPressEventFieldCallback` into a `C_WidgetClassKeyPressEventFieldCallback`.

## WidgetClassKeyReleaseEventFieldCallback

type C_WidgetClassKeyReleaseEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt Source #

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

type WidgetClassKeyReleaseEventFieldCallback = Widget -> EventKey -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassKeyReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyReleaseEventFieldCallback -> a -> EventKey -> m Bool Source #

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

genClosure_WidgetClassKeyReleaseEventFieldCallback :: MonadIO m => WidgetClassKeyReleaseEventFieldCallback -> m (GClosure C_WidgetClassKeyReleaseEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassKeyReleaseEventFieldCallback :: C_WidgetClassKeyReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassKeyReleaseEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassKeyReleaseEventFieldCallback`.

noWidgetClassKeyReleaseEventFieldCallback :: Maybe WidgetClassKeyReleaseEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassKeyReleaseEventFieldCallback``.

wrap_WidgetClassKeyReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)) -> WidgetClassKeyReleaseEventFieldCallback -> C_WidgetClassKeyReleaseEventFieldCallback Source #

Wrap a `WidgetClassKeyReleaseEventFieldCallback` into a `C_WidgetClassKeyReleaseEventFieldCallback`.

## WidgetClassKeynavFailedFieldCallback

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

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

type WidgetClassKeynavFailedFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget`
-> DirectionType | `direction`: direction of focus movement
-> IO Bool | Returns: `True` if stopping keyboard navigation is fine, `False` if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).

No description available in the introspection data.

dynamic_WidgetClassKeynavFailedFieldCallback Source #

Arguments

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

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

genClosure_WidgetClassKeynavFailedFieldCallback :: MonadIO m => WidgetClassKeynavFailedFieldCallback -> m (GClosure C_WidgetClassKeynavFailedFieldCallback) Source #

Wrap the callback into a `GClosure`.

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

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

noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassKeynavFailedFieldCallback``.

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

Wrap a `WidgetClassKeynavFailedFieldCallback` into a `C_WidgetClassKeynavFailedFieldCallback`.

## WidgetClassLeaveNotifyEventFieldCallback

type C_WidgetClassLeaveNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt Source #

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

type WidgetClassLeaveNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassLeaveNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassLeaveNotifyEventFieldCallback -> a -> EventCrossing -> m Bool Source #

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

genClosure_WidgetClassLeaveNotifyEventFieldCallback :: MonadIO m => WidgetClassLeaveNotifyEventFieldCallback -> m (GClosure C_WidgetClassLeaveNotifyEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassLeaveNotifyEventFieldCallback :: C_WidgetClassLeaveNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassLeaveNotifyEventFieldCallback`.

noWidgetClassLeaveNotifyEventFieldCallback :: Maybe WidgetClassLeaveNotifyEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassLeaveNotifyEventFieldCallback``.

wrap_WidgetClassLeaveNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)) -> WidgetClassLeaveNotifyEventFieldCallback -> C_WidgetClassLeaveNotifyEventFieldCallback Source #

Wrap a `WidgetClassLeaveNotifyEventFieldCallback` into a `C_WidgetClassLeaveNotifyEventFieldCallback`.

## WidgetClassMapEventFieldCallback

type C_WidgetClassMapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt Source #

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

type WidgetClassMapEventFieldCallback = Widget -> EventAny -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassMapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapEventFieldCallback -> a -> EventAny -> m Bool Source #

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

genClosure_WidgetClassMapEventFieldCallback :: MonadIO m => WidgetClassMapEventFieldCallback -> m (GClosure C_WidgetClassMapEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassMapEventFieldCallback :: C_WidgetClassMapEventFieldCallback -> IO (FunPtr C_WidgetClassMapEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassMapEventFieldCallback`.

noWidgetClassMapEventFieldCallback :: Maybe WidgetClassMapEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassMapEventFieldCallback``.

wrap_WidgetClassMapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapEventFieldCallback)) -> WidgetClassMapEventFieldCallback -> C_WidgetClassMapEventFieldCallback Source #

Wrap a `WidgetClassMapEventFieldCallback` into a `C_WidgetClassMapEventFieldCallback`.

## WidgetClassMapFieldCallback

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

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

type WidgetClassMapFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassMapFieldCallback Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassMapFieldCallback``.

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

Wrap a `WidgetClassMapFieldCallback` into a `C_WidgetClassMapFieldCallback`.

## WidgetClassMnemonicActivateFieldCallback

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

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

type WidgetClassMnemonicActivateFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassMnemonicActivateFieldCallback Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassMnemonicActivateFieldCallback``.

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

Wrap a `WidgetClassMnemonicActivateFieldCallback` into a `C_WidgetClassMnemonicActivateFieldCallback`.

## WidgetClassMotionNotifyEventFieldCallback

type C_WidgetClassMotionNotifyEventFieldCallback = Ptr Widget -> Ptr EventMotion -> IO CInt Source #

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

type WidgetClassMotionNotifyEventFieldCallback = Widget -> EventMotion -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassMotionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> a -> EventMotion -> m Bool Source #

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

genClosure_WidgetClassMotionNotifyEventFieldCallback :: MonadIO m => WidgetClassMotionNotifyEventFieldCallback -> m (GClosure C_WidgetClassMotionNotifyEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassMotionNotifyEventFieldCallback :: C_WidgetClassMotionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassMotionNotifyEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassMotionNotifyEventFieldCallback`.

noWidgetClassMotionNotifyEventFieldCallback :: Maybe WidgetClassMotionNotifyEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassMotionNotifyEventFieldCallback``.

wrap_WidgetClassMotionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)) -> WidgetClassMotionNotifyEventFieldCallback -> C_WidgetClassMotionNotifyEventFieldCallback Source #

Wrap a `WidgetClassMotionNotifyEventFieldCallback` into a `C_WidgetClassMotionNotifyEventFieldCallback`.

## WidgetClassMoveFocusFieldCallback

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

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

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

No description available in the introspection data.

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

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

genClosure_WidgetClassMoveFocusFieldCallback :: MonadIO m => WidgetClassMoveFocusFieldCallback -> m (GClosure C_WidgetClassMoveFocusFieldCallback) Source #

Wrap the callback into a `GClosure`.

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

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

noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassMoveFocusFieldCallback``.

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

Wrap a `WidgetClassMoveFocusFieldCallback` into a `C_WidgetClassMoveFocusFieldCallback`.

## WidgetClassParentSetFieldCallback

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

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

type WidgetClassParentSetFieldCallback = Widget -> Widget -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassParentSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassParentSetFieldCallback -> a -> b -> m () Source #

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

genClosure_WidgetClassParentSetFieldCallback :: MonadIO m => WidgetClassParentSetFieldCallback -> m (GClosure C_WidgetClassParentSetFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassParentSetFieldCallback :: C_WidgetClassParentSetFieldCallback -> IO (FunPtr C_WidgetClassParentSetFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassParentSetFieldCallback`.

noWidgetClassParentSetFieldCallback :: Maybe WidgetClassParentSetFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassParentSetFieldCallback``.

wrap_WidgetClassParentSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassParentSetFieldCallback)) -> WidgetClassParentSetFieldCallback -> C_WidgetClassParentSetFieldCallback Source #

Wrap a `WidgetClassParentSetFieldCallback` into a `C_WidgetClassParentSetFieldCallback`.

## WidgetClassPopupMenuFieldCallback

type C_WidgetClassPopupMenuFieldCallback = Ptr Widget -> IO CInt Source #

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

type WidgetClassPopupMenuFieldCallback = Widget -> IO Bool Source #

No description available in the introspection data.

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

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

genClosure_WidgetClassPopupMenuFieldCallback :: MonadIO m => WidgetClassPopupMenuFieldCallback -> m (GClosure C_WidgetClassPopupMenuFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassPopupMenuFieldCallback :: C_WidgetClassPopupMenuFieldCallback -> IO (FunPtr C_WidgetClassPopupMenuFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassPopupMenuFieldCallback`.

noWidgetClassPopupMenuFieldCallback :: Maybe WidgetClassPopupMenuFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassPopupMenuFieldCallback``.

wrap_WidgetClassPopupMenuFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)) -> WidgetClassPopupMenuFieldCallback -> C_WidgetClassPopupMenuFieldCallback Source #

Wrap a `WidgetClassPopupMenuFieldCallback` into a `C_WidgetClassPopupMenuFieldCallback`.

## WidgetClassPropertyNotifyEventFieldCallback

type C_WidgetClassPropertyNotifyEventFieldCallback = Ptr Widget -> Ptr EventProperty -> IO CInt Source #

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

type WidgetClassPropertyNotifyEventFieldCallback = Widget -> EventProperty -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassPropertyNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> a -> EventProperty -> m Bool Source #

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

genClosure_WidgetClassPropertyNotifyEventFieldCallback :: MonadIO m => WidgetClassPropertyNotifyEventFieldCallback -> m (GClosure C_WidgetClassPropertyNotifyEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassPropertyNotifyEventFieldCallback :: C_WidgetClassPropertyNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassPropertyNotifyEventFieldCallback`.

noWidgetClassPropertyNotifyEventFieldCallback :: Maybe WidgetClassPropertyNotifyEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassPropertyNotifyEventFieldCallback``.

wrap_WidgetClassPropertyNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)) -> WidgetClassPropertyNotifyEventFieldCallback -> C_WidgetClassPropertyNotifyEventFieldCallback Source #

Wrap a `WidgetClassPropertyNotifyEventFieldCallback` into a `C_WidgetClassPropertyNotifyEventFieldCallback`.

## WidgetClassProximityInEventFieldCallback

type C_WidgetClassProximityInEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt Source #

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

type WidgetClassProximityInEventFieldCallback = Widget -> EventProximity -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassProximityInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityInEventFieldCallback -> a -> EventProximity -> m Bool Source #

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

genClosure_WidgetClassProximityInEventFieldCallback :: MonadIO m => WidgetClassProximityInEventFieldCallback -> m (GClosure C_WidgetClassProximityInEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassProximityInEventFieldCallback :: C_WidgetClassProximityInEventFieldCallback -> IO (FunPtr C_WidgetClassProximityInEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassProximityInEventFieldCallback`.

noWidgetClassProximityInEventFieldCallback :: Maybe WidgetClassProximityInEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassProximityInEventFieldCallback``.

wrap_WidgetClassProximityInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)) -> WidgetClassProximityInEventFieldCallback -> C_WidgetClassProximityInEventFieldCallback Source #

Wrap a `WidgetClassProximityInEventFieldCallback` into a `C_WidgetClassProximityInEventFieldCallback`.

## WidgetClassProximityOutEventFieldCallback

type C_WidgetClassProximityOutEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt Source #

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

type WidgetClassProximityOutEventFieldCallback = Widget -> EventProximity -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassProximityOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityOutEventFieldCallback -> a -> EventProximity -> m Bool Source #

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

genClosure_WidgetClassProximityOutEventFieldCallback :: MonadIO m => WidgetClassProximityOutEventFieldCallback -> m (GClosure C_WidgetClassProximityOutEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassProximityOutEventFieldCallback :: C_WidgetClassProximityOutEventFieldCallback -> IO (FunPtr C_WidgetClassProximityOutEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassProximityOutEventFieldCallback`.

noWidgetClassProximityOutEventFieldCallback :: Maybe WidgetClassProximityOutEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassProximityOutEventFieldCallback``.

wrap_WidgetClassProximityOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityOutEventFieldCallback)) -> WidgetClassProximityOutEventFieldCallback -> C_WidgetClassProximityOutEventFieldCallback Source #

Wrap a `WidgetClassProximityOutEventFieldCallback` into a `C_WidgetClassProximityOutEventFieldCallback`.

## WidgetClassQueryTooltipFieldCallback

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

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

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

No description available in the introspection data.

dynamic_WidgetClassQueryTooltipFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsTooltip b) => FunPtr C_WidgetClassQueryTooltipFieldCallback -> a -> Int32 -> Int32 -> Bool -> b -> m Bool Source #

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

genClosure_WidgetClassQueryTooltipFieldCallback :: MonadIO m => WidgetClassQueryTooltipFieldCallback -> m (GClosure C_WidgetClassQueryTooltipFieldCallback) Source #

Wrap the callback into a `GClosure`.

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

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

noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassQueryTooltipFieldCallback``.

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

Wrap a `WidgetClassQueryTooltipFieldCallback` into a `C_WidgetClassQueryTooltipFieldCallback`.

## WidgetClassQueueDrawRegionFieldCallback

type C_WidgetClassQueueDrawRegionFieldCallback = Ptr Widget -> Ptr Region -> IO () Source #

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

type WidgetClassQueueDrawRegionFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget`
-> Region | `region`: region to draw
-> IO () |

No description available in the introspection data.

dynamic_WidgetClassQueueDrawRegionFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassQueueDrawRegionFieldCallback |
-> a | `widget`: a `Widget`
-> Region | `region`: region to draw
-> m () |

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

genClosure_WidgetClassQueueDrawRegionFieldCallback :: MonadIO m => WidgetClassQueueDrawRegionFieldCallback -> m (GClosure C_WidgetClassQueueDrawRegionFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassQueueDrawRegionFieldCallback :: C_WidgetClassQueueDrawRegionFieldCallback -> IO (FunPtr C_WidgetClassQueueDrawRegionFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassQueueDrawRegionFieldCallback`.

noWidgetClassQueueDrawRegionFieldCallback :: Maybe WidgetClassQueueDrawRegionFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassQueueDrawRegionFieldCallback``.

wrap_WidgetClassQueueDrawRegionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)) -> WidgetClassQueueDrawRegionFieldCallback -> C_WidgetClassQueueDrawRegionFieldCallback Source #

Wrap a `WidgetClassQueueDrawRegionFieldCallback` into a `C_WidgetClassQueueDrawRegionFieldCallback`.

## WidgetClassRealizeFieldCallback

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

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

type WidgetClassRealizeFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassRealizeFieldCallback Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassRealizeFieldCallback``.

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

Wrap a `WidgetClassRealizeFieldCallback` into a `C_WidgetClassRealizeFieldCallback`.

## WidgetClassScreenChangedFieldCallback

type C_WidgetClassScreenChangedFieldCallback = Ptr Widget -> Ptr Screen -> IO () Source #

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

type WidgetClassScreenChangedFieldCallback = Widget -> Screen -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassScreenChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsScreen b) => FunPtr C_WidgetClassScreenChangedFieldCallback -> a -> b -> m () Source #

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

genClosure_WidgetClassScreenChangedFieldCallback :: MonadIO m => WidgetClassScreenChangedFieldCallback -> m (GClosure C_WidgetClassScreenChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassScreenChangedFieldCallback :: C_WidgetClassScreenChangedFieldCallback -> IO (FunPtr C_WidgetClassScreenChangedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassScreenChangedFieldCallback`.

noWidgetClassScreenChangedFieldCallback :: Maybe WidgetClassScreenChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassScreenChangedFieldCallback``.

wrap_WidgetClassScreenChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)) -> WidgetClassScreenChangedFieldCallback -> C_WidgetClassScreenChangedFieldCallback Source #

Wrap a `WidgetClassScreenChangedFieldCallback` into a `C_WidgetClassScreenChangedFieldCallback`.

## WidgetClassScrollEventFieldCallback

type C_WidgetClassScrollEventFieldCallback = Ptr Widget -> Ptr EventScroll -> IO CInt Source #

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

type WidgetClassScrollEventFieldCallback = Widget -> EventScroll -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassScrollEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassScrollEventFieldCallback -> a -> EventScroll -> m Bool Source #

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

genClosure_WidgetClassScrollEventFieldCallback :: MonadIO m => WidgetClassScrollEventFieldCallback -> m (GClosure C_WidgetClassScrollEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassScrollEventFieldCallback :: C_WidgetClassScrollEventFieldCallback -> IO (FunPtr C_WidgetClassScrollEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassScrollEventFieldCallback`.

noWidgetClassScrollEventFieldCallback :: Maybe WidgetClassScrollEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassScrollEventFieldCallback``.

wrap_WidgetClassScrollEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScrollEventFieldCallback)) -> WidgetClassScrollEventFieldCallback -> C_WidgetClassScrollEventFieldCallback Source #

Wrap a `WidgetClassScrollEventFieldCallback` into a `C_WidgetClassScrollEventFieldCallback`.

## WidgetClassSelectionClearEventFieldCallback

type C_WidgetClassSelectionClearEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt Source #

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

type WidgetClassSelectionClearEventFieldCallback = Widget -> EventSelection -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassSelectionClearEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionClearEventFieldCallback -> a -> EventSelection -> m Bool Source #

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

genClosure_WidgetClassSelectionClearEventFieldCallback :: MonadIO m => WidgetClassSelectionClearEventFieldCallback -> m (GClosure C_WidgetClassSelectionClearEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassSelectionClearEventFieldCallback :: C_WidgetClassSelectionClearEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionClearEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassSelectionClearEventFieldCallback`.

noWidgetClassSelectionClearEventFieldCallback :: Maybe WidgetClassSelectionClearEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassSelectionClearEventFieldCallback``.

wrap_WidgetClassSelectionClearEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)) -> WidgetClassSelectionClearEventFieldCallback -> C_WidgetClassSelectionClearEventFieldCallback Source #

Wrap a `WidgetClassSelectionClearEventFieldCallback` into a `C_WidgetClassSelectionClearEventFieldCallback`.

## WidgetClassSelectionGetFieldCallback

type C_WidgetClassSelectionGetFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> Word32 -> IO () Source #

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

type WidgetClassSelectionGetFieldCallback = Widget -> SelectionData -> Word32 -> Word32 -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassSelectionGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionGetFieldCallback -> a -> SelectionData -> Word32 -> Word32 -> m () Source #

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

genClosure_WidgetClassSelectionGetFieldCallback :: MonadIO m => WidgetClassSelectionGetFieldCallback -> m (GClosure C_WidgetClassSelectionGetFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassSelectionGetFieldCallback :: C_WidgetClassSelectionGetFieldCallback -> IO (FunPtr C_WidgetClassSelectionGetFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassSelectionGetFieldCallback`.

noWidgetClassSelectionGetFieldCallback :: Maybe WidgetClassSelectionGetFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassSelectionGetFieldCallback``.

wrap_WidgetClassSelectionGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionGetFieldCallback)) -> WidgetClassSelectionGetFieldCallback -> C_WidgetClassSelectionGetFieldCallback Source #

Wrap a `WidgetClassSelectionGetFieldCallback` into a `C_WidgetClassSelectionGetFieldCallback`.

## WidgetClassSelectionNotifyEventFieldCallback

type C_WidgetClassSelectionNotifyEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt Source #

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

type WidgetClassSelectionNotifyEventFieldCallback = Widget -> EventSelection -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassSelectionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionNotifyEventFieldCallback -> a -> EventSelection -> m Bool Source #

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

genClosure_WidgetClassSelectionNotifyEventFieldCallback :: MonadIO m => WidgetClassSelectionNotifyEventFieldCallback -> m (GClosure C_WidgetClassSelectionNotifyEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassSelectionNotifyEventFieldCallback :: C_WidgetClassSelectionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassSelectionNotifyEventFieldCallback`.

noWidgetClassSelectionNotifyEventFieldCallback :: Maybe WidgetClassSelectionNotifyEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassSelectionNotifyEventFieldCallback``.

wrap_WidgetClassSelectionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)) -> WidgetClassSelectionNotifyEventFieldCallback -> C_WidgetClassSelectionNotifyEventFieldCallback Source #

Wrap a `WidgetClassSelectionNotifyEventFieldCallback` into a `C_WidgetClassSelectionNotifyEventFieldCallback`.

## WidgetClassSelectionReceivedFieldCallback

type C_WidgetClassSelectionReceivedFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> IO () Source #

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

type WidgetClassSelectionReceivedFieldCallback = Widget -> SelectionData -> Word32 -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassSelectionReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionReceivedFieldCallback -> a -> SelectionData -> Word32 -> m () Source #

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

genClosure_WidgetClassSelectionReceivedFieldCallback :: MonadIO m => WidgetClassSelectionReceivedFieldCallback -> m (GClosure C_WidgetClassSelectionReceivedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassSelectionReceivedFieldCallback :: C_WidgetClassSelectionReceivedFieldCallback -> IO (FunPtr C_WidgetClassSelectionReceivedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassSelectionReceivedFieldCallback`.

noWidgetClassSelectionReceivedFieldCallback :: Maybe WidgetClassSelectionReceivedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassSelectionReceivedFieldCallback``.

wrap_WidgetClassSelectionReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionReceivedFieldCallback)) -> WidgetClassSelectionReceivedFieldCallback -> C_WidgetClassSelectionReceivedFieldCallback Source #

Wrap a `WidgetClassSelectionReceivedFieldCallback` into a `C_WidgetClassSelectionReceivedFieldCallback`.

## WidgetClassSelectionRequestEventFieldCallback

type C_WidgetClassSelectionRequestEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt Source #

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

type WidgetClassSelectionRequestEventFieldCallback = Widget -> EventSelection -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassSelectionRequestEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionRequestEventFieldCallback -> a -> EventSelection -> m Bool Source #

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

genClosure_WidgetClassSelectionRequestEventFieldCallback :: MonadIO m => WidgetClassSelectionRequestEventFieldCallback -> m (GClosure C_WidgetClassSelectionRequestEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassSelectionRequestEventFieldCallback :: C_WidgetClassSelectionRequestEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionRequestEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassSelectionRequestEventFieldCallback`.

noWidgetClassSelectionRequestEventFieldCallback :: Maybe WidgetClassSelectionRequestEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassSelectionRequestEventFieldCallback``.

wrap_WidgetClassSelectionRequestEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)) -> WidgetClassSelectionRequestEventFieldCallback -> C_WidgetClassSelectionRequestEventFieldCallback Source #

Wrap a `WidgetClassSelectionRequestEventFieldCallback` into a `C_WidgetClassSelectionRequestEventFieldCallback`.

## WidgetClassShowAllFieldCallback

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

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

type WidgetClassShowAllFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassShowAllFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassShowAllFieldCallback |
-> a | `widget`: a `Widget`
-> m () |

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

genClosure_WidgetClassShowAllFieldCallback :: MonadIO m => WidgetClassShowAllFieldCallback -> m (GClosure C_WidgetClassShowAllFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassShowAllFieldCallback :: C_WidgetClassShowAllFieldCallback -> IO (FunPtr C_WidgetClassShowAllFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassShowAllFieldCallback`.

noWidgetClassShowAllFieldCallback :: Maybe WidgetClassShowAllFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassShowAllFieldCallback``.

wrap_WidgetClassShowAllFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowAllFieldCallback)) -> WidgetClassShowAllFieldCallback -> C_WidgetClassShowAllFieldCallback Source #

Wrap a `WidgetClassShowAllFieldCallback` into a `C_WidgetClassShowAllFieldCallback`.

## WidgetClassShowFieldCallback

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

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

type WidgetClassShowFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassShowFieldCallback Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassShowFieldCallback``.

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

Wrap a `WidgetClassShowFieldCallback` into a `C_WidgetClassShowFieldCallback`.

## WidgetClassShowHelpFieldCallback

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

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

type WidgetClassShowHelpFieldCallback = Widget -> WidgetHelpType -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassShowHelpFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowHelpFieldCallback -> a -> WidgetHelpType -> m Bool Source #

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

genClosure_WidgetClassShowHelpFieldCallback :: MonadIO m => WidgetClassShowHelpFieldCallback -> m (GClosure C_WidgetClassShowHelpFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassShowHelpFieldCallback :: C_WidgetClassShowHelpFieldCallback -> IO (FunPtr C_WidgetClassShowHelpFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassShowHelpFieldCallback`.

noWidgetClassShowHelpFieldCallback :: Maybe WidgetClassShowHelpFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassShowHelpFieldCallback``.

wrap_WidgetClassShowHelpFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowHelpFieldCallback)) -> WidgetClassShowHelpFieldCallback -> C_WidgetClassShowHelpFieldCallback Source #

Wrap a `WidgetClassShowHelpFieldCallback` into a `C_WidgetClassShowHelpFieldCallback`.

## WidgetClassSizeAllocateFieldCallback

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

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

type WidgetClassSizeAllocateFieldCallback Source #

Arguments

= Widget | `widget`: a `Widget`
-> Rectangle | `allocation`: position and size to be allocated to `widget`
-> IO () |

No description available in the introspection data.

dynamic_WidgetClassSizeAllocateFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) |
=> FunPtr C_WidgetClassSizeAllocateFieldCallback |
-> a | `widget`: a `Widget`
-> Rectangle | `allocation`: position and size to be allocated to `widget`
-> m () |

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

genClosure_WidgetClassSizeAllocateFieldCallback :: MonadIO m => WidgetClassSizeAllocateFieldCallback -> m (GClosure C_WidgetClassSizeAllocateFieldCallback) Source #

Wrap the callback into a `GClosure`.

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

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

noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassSizeAllocateFieldCallback``.

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

Wrap a `WidgetClassSizeAllocateFieldCallback` into a `C_WidgetClassSizeAllocateFieldCallback`.

## WidgetClassStateChangedFieldCallback

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

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

type WidgetClassStateChangedFieldCallback = Widget -> StateType -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassStateChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateChangedFieldCallback -> a -> StateType -> m () Source #

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

genClosure_WidgetClassStateChangedFieldCallback :: MonadIO m => WidgetClassStateChangedFieldCallback -> m (GClosure C_WidgetClassStateChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassStateChangedFieldCallback :: C_WidgetClassStateChangedFieldCallback -> IO (FunPtr C_WidgetClassStateChangedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassStateChangedFieldCallback`.

noWidgetClassStateChangedFieldCallback :: Maybe WidgetClassStateChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassStateChangedFieldCallback``.

wrap_WidgetClassStateChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)) -> WidgetClassStateChangedFieldCallback -> C_WidgetClassStateChangedFieldCallback Source #

Wrap a `WidgetClassStateChangedFieldCallback` into a `C_WidgetClassStateChangedFieldCallback`.

## WidgetClassStateFlagsChangedFieldCallback

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

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

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

No description available in the introspection data.

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

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

genClosure_WidgetClassStateFlagsChangedFieldCallback :: MonadIO m => WidgetClassStateFlagsChangedFieldCallback -> m (GClosure C_WidgetClassStateFlagsChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

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

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

noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassStateFlagsChangedFieldCallback``.

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

Wrap a `WidgetClassStateFlagsChangedFieldCallback` into a `C_WidgetClassStateFlagsChangedFieldCallback`.

## WidgetClassStyleSetFieldCallback

type C_WidgetClassStyleSetFieldCallback = Ptr Widget -> Ptr Style -> IO () Source #

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

type WidgetClassStyleSetFieldCallback = Widget -> Style -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassStyleSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsStyle b) => FunPtr C_WidgetClassStyleSetFieldCallback -> a -> b -> m () Source #

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

genClosure_WidgetClassStyleSetFieldCallback :: MonadIO m => WidgetClassStyleSetFieldCallback -> m (GClosure C_WidgetClassStyleSetFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassStyleSetFieldCallback :: C_WidgetClassStyleSetFieldCallback -> IO (FunPtr C_WidgetClassStyleSetFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassStyleSetFieldCallback`.

noWidgetClassStyleSetFieldCallback :: Maybe WidgetClassStyleSetFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassStyleSetFieldCallback``.

wrap_WidgetClassStyleSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleSetFieldCallback)) -> WidgetClassStyleSetFieldCallback -> C_WidgetClassStyleSetFieldCallback Source #

Wrap a `WidgetClassStyleSetFieldCallback` into a `C_WidgetClassStyleSetFieldCallback`.

## WidgetClassStyleUpdatedFieldCallback

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

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

type WidgetClassStyleUpdatedFieldCallback = Widget -> IO () Source #

No description available in the introspection data.

dynamic_WidgetClassStyleUpdatedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStyleUpdatedFieldCallback -> a -> m () Source #

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

genClosure_WidgetClassStyleUpdatedFieldCallback :: MonadIO m => WidgetClassStyleUpdatedFieldCallback -> m (GClosure C_WidgetClassStyleUpdatedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassStyleUpdatedFieldCallback :: C_WidgetClassStyleUpdatedFieldCallback -> IO (FunPtr C_WidgetClassStyleUpdatedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassStyleUpdatedFieldCallback`.

noWidgetClassStyleUpdatedFieldCallback :: Maybe WidgetClassStyleUpdatedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassStyleUpdatedFieldCallback``.

wrap_WidgetClassStyleUpdatedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleUpdatedFieldCallback)) -> WidgetClassStyleUpdatedFieldCallback -> C_WidgetClassStyleUpdatedFieldCallback Source #

Wrap a `WidgetClassStyleUpdatedFieldCallback` into a `C_WidgetClassStyleUpdatedFieldCallback`.

## WidgetClassTouchEventFieldCallback

type C_WidgetClassTouchEventFieldCallback = Ptr Widget -> Ptr EventTouch -> IO CInt Source #

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

type WidgetClassTouchEventFieldCallback = Widget -> EventTouch -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassTouchEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassTouchEventFieldCallback -> a -> EventTouch -> m Bool Source #

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

genClosure_WidgetClassTouchEventFieldCallback :: MonadIO m => WidgetClassTouchEventFieldCallback -> m (GClosure C_WidgetClassTouchEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassTouchEventFieldCallback :: C_WidgetClassTouchEventFieldCallback -> IO (FunPtr C_WidgetClassTouchEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassTouchEventFieldCallback`.

noWidgetClassTouchEventFieldCallback :: Maybe WidgetClassTouchEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassTouchEventFieldCallback``.

wrap_WidgetClassTouchEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassTouchEventFieldCallback)) -> WidgetClassTouchEventFieldCallback -> C_WidgetClassTouchEventFieldCallback Source #

Wrap a `WidgetClassTouchEventFieldCallback` into a `C_WidgetClassTouchEventFieldCallback`.

## WidgetClassUnmapEventFieldCallback

type C_WidgetClassUnmapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt Source #

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

type WidgetClassUnmapEventFieldCallback = Widget -> EventAny -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassUnmapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapEventFieldCallback -> a -> EventAny -> m Bool Source #

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

genClosure_WidgetClassUnmapEventFieldCallback :: MonadIO m => WidgetClassUnmapEventFieldCallback -> m (GClosure C_WidgetClassUnmapEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassUnmapEventFieldCallback :: C_WidgetClassUnmapEventFieldCallback -> IO (FunPtr C_WidgetClassUnmapEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassUnmapEventFieldCallback`.

noWidgetClassUnmapEventFieldCallback :: Maybe WidgetClassUnmapEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassUnmapEventFieldCallback``.

wrap_WidgetClassUnmapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapEventFieldCallback)) -> WidgetClassUnmapEventFieldCallback -> C_WidgetClassUnmapEventFieldCallback Source #

Wrap a `WidgetClassUnmapEventFieldCallback` into a `C_WidgetClassUnmapEventFieldCallback`.

## WidgetClassUnmapFieldCallback

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

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

type WidgetClassUnmapFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassUnmapFieldCallback Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

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

noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassUnmapFieldCallback``.

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

Wrap a `WidgetClassUnmapFieldCallback` into a `C_WidgetClassUnmapFieldCallback`.

## WidgetClassUnrealizeFieldCallback

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

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

type WidgetClassUnrealizeFieldCallback Source #

Arguments

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

No description available in the introspection data.

dynamic_WidgetClassUnrealizeFieldCallback Source #

Arguments

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

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

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

Wrap the callback into a `GClosure`.

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

Generate a function pointer callable from C code, from a `C_WidgetClassUnrealizeFieldCallback`.

noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassUnrealizeFieldCallback``.

wrap_WidgetClassUnrealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrealizeFieldCallback)) -> WidgetClassUnrealizeFieldCallback -> C_WidgetClassUnrealizeFieldCallback Source #

Wrap a `WidgetClassUnrealizeFieldCallback` into a `C_WidgetClassUnrealizeFieldCallback`.

## WidgetClassVisibilityNotifyEventFieldCallback

type C_WidgetClassVisibilityNotifyEventFieldCallback = Ptr Widget -> Ptr EventVisibility -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

type WidgetClassVisibilityNotifyEventFieldCallback = Widget -> EventVisibility -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassVisibilityNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> a -> EventVisibility -> m Bool Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_WidgetClassVisibilityNotifyEventFieldCallback :: MonadIO m => WidgetClassVisibilityNotifyEventFieldCallback -> m (GClosure C_WidgetClassVisibilityNotifyEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassVisibilityNotifyEventFieldCallback :: C_WidgetClassVisibilityNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassVisibilityNotifyEventFieldCallback`.

noWidgetClassVisibilityNotifyEventFieldCallback :: Maybe WidgetClassVisibilityNotifyEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassVisibilityNotifyEventFieldCallback``.

wrap_WidgetClassVisibilityNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)) -> WidgetClassVisibilityNotifyEventFieldCallback -> C_WidgetClassVisibilityNotifyEventFieldCallback Source #

Wrap a `WidgetClassVisibilityNotifyEventFieldCallback` into a `C_WidgetClassVisibilityNotifyEventFieldCallback`.

## WidgetClassWindowStateEventFieldCallback

type C_WidgetClassWindowStateEventFieldCallback = Ptr Widget -> Ptr EventWindowState -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

type WidgetClassWindowStateEventFieldCallback = Widget -> EventWindowState -> IO Bool Source #

No description available in the introspection data.

dynamic_WidgetClassWindowStateEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassWindowStateEventFieldCallback -> a -> EventWindowState -> m Bool Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_WidgetClassWindowStateEventFieldCallback :: MonadIO m => WidgetClassWindowStateEventFieldCallback -> m (GClosure C_WidgetClassWindowStateEventFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_WidgetClassWindowStateEventFieldCallback :: C_WidgetClassWindowStateEventFieldCallback -> IO (FunPtr C_WidgetClassWindowStateEventFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_WidgetClassWindowStateEventFieldCallback`.

noWidgetClassWindowStateEventFieldCallback :: Maybe WidgetClassWindowStateEventFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `WidgetClassWindowStateEventFieldCallback``.

wrap_WidgetClassWindowStateEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassWindowStateEventFieldCallback)) -> WidgetClassWindowStateEventFieldCallback -> C_WidgetClassWindowStateEventFieldCallback Source #

Wrap a `WidgetClassWindowStateEventFieldCallback` into a `C_WidgetClassWindowStateEventFieldCallback`.