GI.Gtk.Callbacks

Signals

AccelGroupActivate

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

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

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

genClosure_AccelGroupActivate :: AccelGroupActivate -> IO Closure

mk_AccelGroupActivate :: C_AccelGroupActivate -> IO (FunPtr C_AccelGroupActivate)

noAccelGroupActivate :: Maybe AccelGroupActivate

wrap_AccelGroupActivate :: Maybe (Ptr (FunPtr C_AccelGroupActivate)) -> AccelGroupActivate -> Ptr AccelGroup -> Ptr Object -> Word32 -> CUInt -> IO CInt

AccelGroupFindFunc

type AccelGroupFindFunc = AccelKey -> Closure -> IO Bool

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

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

drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures

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

genClosure_AccelGroupFindFunc :: AccelGroupFindFunc -> IO Closure

mk_AccelGroupFindFunc :: C_AccelGroupFindFunc -> IO (FunPtr C_AccelGroupFindFunc)

noAccelGroupFindFunc :: Maybe AccelGroupFindFunc

noAccelGroupFindFunc_WithClosures :: Maybe AccelGroupFindFunc_WithClosures

wrap_AccelGroupFindFunc :: Maybe (Ptr (FunPtr C_AccelGroupFindFunc)) -> AccelGroupFindFunc_WithClosures -> Ptr AccelKey -> Ptr Closure -> Ptr () -> IO CInt

AccelMapForeach

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

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

dynamic_AccelMapForeach

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

genClosure_AccelMapForeach :: AccelMapForeach -> IO Closure

mk_AccelMapForeach :: C_AccelMapForeach -> IO (FunPtr C_AccelMapForeach)

noAccelMapForeach :: Maybe AccelMapForeach

wrap_AccelMapForeach :: Maybe (Ptr (FunPtr C_AccelMapForeach)) -> AccelMapForeach -> Ptr () -> CString -> Word32 -> CUInt -> CInt -> IO ()

AssistantPageFunc

type AssistantPageFunc = Int32 -> IO Int32

type AssistantPageFunc_WithClosures = Int32 -> Ptr () -> IO Int32

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

drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures

dynamic_AssistantPageFunc

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.

genClosure_AssistantPageFunc :: AssistantPageFunc -> IO Closure

mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)

noAssistantPageFunc :: Maybe AssistantPageFunc

noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures

wrap_AssistantPageFunc :: Maybe (Ptr (FunPtr C_AssistantPageFunc)) -> AssistantPageFunc_WithClosures -> Int32 -> Ptr () -> IO Int32

BuilderConnectFunc

type BuilderConnectFunc = Builder -> Object -> Text -> Text -> Maybe Object -> [ConnectFlags] -> IO ()

type BuilderConnectFunc_WithClosures = Builder -> Object -> Text -> Text -> Maybe Object -> [ConnectFlags] -> Ptr () -> IO ()

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

drop_closures_BuilderConnectFunc :: BuilderConnectFunc -> BuilderConnectFunc_WithClosures

dynamic_BuilderConnectFunc

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

genClosure_BuilderConnectFunc :: BuilderConnectFunc -> IO Closure

mk_BuilderConnectFunc :: C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc)

noBuilderConnectFunc :: Maybe BuilderConnectFunc

noBuilderConnectFunc_WithClosures :: Maybe BuilderConnectFunc_WithClosures

wrap_BuilderConnectFunc :: Maybe (Ptr (FunPtr C_BuilderConnectFunc)) -> BuilderConnectFunc_WithClosures -> Ptr Builder -> Ptr Object -> CString -> CString -> Ptr Object -> CUInt -> Ptr () -> IO ()

CalendarDetailFunc

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

type CalendarDetailFunc = Calendar -> Word32 -> Word32 -> Word32 -> IO (Maybe Text)

type CalendarDetailFunc_WithClosures = Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO (Maybe Text)

drop_closures_CalendarDetailFunc :: CalendarDetailFunc -> CalendarDetailFunc_WithClosures

dynamic_CalendarDetailFunc

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.

genClosure_CalendarDetailFunc :: CalendarDetailFunc -> IO Closure

mk_CalendarDetailFunc :: C_CalendarDetailFunc -> IO (FunPtr C_CalendarDetailFunc)

noCalendarDetailFunc :: Maybe CalendarDetailFunc

noCalendarDetailFunc_WithClosures :: Maybe CalendarDetailFunc_WithClosures

wrap_CalendarDetailFunc :: Maybe (Ptr (FunPtr C_CalendarDetailFunc)) -> CalendarDetailFunc_WithClosures -> Ptr Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO CString

Callback

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

type Callback = Widget -> IO ()

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

drop_closures_Callback :: Callback -> Callback_WithClosures

dynamic_Callback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> FunPtr C_Callback

-> a

widget: the widget to operate on

-> Ptr ()

data: user-supplied data

-> m ()

genClosure_Callback :: Callback -> IO Closure

mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

noCallback :: Maybe Callback

noCallback_WithClosures :: Maybe Callback_WithClosures

wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback_WithClosures -> Ptr Widget -> Ptr () -> IO ()

CellAllocCallback

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

type CellAllocCallback = CellRenderer -> Rectangle -> Rectangle -> IO Bool

type CellAllocCallback_WithClosures = CellRenderer -> Rectangle -> Rectangle -> Ptr () -> IO Bool

drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures

dynamic_CellAllocCallback

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.

genClosure_CellAllocCallback :: CellAllocCallback -> IO Closure

mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback)

noCellAllocCallback :: Maybe CellAllocCallback

noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures

wrap_CellAllocCallback :: Maybe (Ptr (FunPtr C_CellAllocCallback)) -> CellAllocCallback_WithClosures -> Ptr CellRenderer -> Ptr Rectangle -> Ptr Rectangle -> Ptr () -> IO CInt

CellCallback

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

type CellCallback = CellRenderer -> IO Bool

type CellCallback_WithClosures = CellRenderer -> Ptr () -> IO Bool

drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures

dynamic_CellCallback

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.

genClosure_CellCallback :: CellCallback -> IO Closure

mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback)

noCellCallback :: Maybe CellCallback

noCellCallback_WithClosures :: Maybe CellCallback_WithClosures

wrap_CellCallback :: Maybe (Ptr (FunPtr C_CellCallback)) -> CellCallback_WithClosures -> Ptr CellRenderer -> Ptr () -> IO CInt

CellLayoutDataFunc

type C_CellLayoutDataFunc = Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

type CellLayoutDataFunc = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> IO ()

type CellLayoutDataFunc_WithClosures = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()

drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures

dynamic_CellLayoutDataFunc

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

genClosure_CellLayoutDataFunc :: CellLayoutDataFunc -> IO Closure

mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc)

noCellLayoutDataFunc :: Maybe CellLayoutDataFunc

noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures

wrap_CellLayoutDataFunc :: Maybe (Ptr (FunPtr C_CellLayoutDataFunc)) -> CellLayoutDataFunc_WithClosures -> Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

ClipboardClearFunc

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

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

dynamic_ClipboardClearFunc

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

genClosure_ClipboardClearFunc :: ClipboardClearFunc -> IO Closure

mk_ClipboardClearFunc :: C_ClipboardClearFunc -> IO (FunPtr C_ClipboardClearFunc)

noClipboardClearFunc :: Maybe ClipboardClearFunc

wrap_ClipboardClearFunc :: Maybe (Ptr (FunPtr C_ClipboardClearFunc)) -> ClipboardClearFunc -> Ptr Clipboard -> Ptr () -> IO ()

ClipboardGetFunc

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

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

dynamic_ClipboardGetFunc

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

genClosure_ClipboardGetFunc :: ClipboardGetFunc -> IO Closure

mk_ClipboardGetFunc :: C_ClipboardGetFunc -> IO (FunPtr C_ClipboardGetFunc)

noClipboardGetFunc :: Maybe ClipboardGetFunc

wrap_ClipboardGetFunc :: Maybe (Ptr (FunPtr C_ClipboardGetFunc)) -> ClipboardGetFunc -> Ptr Clipboard -> Ptr SelectionData -> Word32 -> Ptr () -> IO ()

ClipboardImageReceivedFunc

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

type ClipboardImageReceivedFunc = Clipboard -> Pixbuf -> IO ()

type ClipboardImageReceivedFunc_WithClosures = Clipboard -> Pixbuf -> Ptr () -> IO ()

drop_closures_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> ClipboardImageReceivedFunc_WithClosures

dynamic_ClipboardImageReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b)

=> FunPtr C_ClipboardImageReceivedFunc

-> a

clipboard: the Clipboard

-> b

pixbuf: the received image

-> Ptr ()

data: the userData supplied to clipboardRequestImage.

-> m ()

genClosure_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> IO Closure

mk_ClipboardImageReceivedFunc :: C_ClipboardImageReceivedFunc -> IO (FunPtr C_ClipboardImageReceivedFunc)

noClipboardImageReceivedFunc :: Maybe ClipboardImageReceivedFunc

noClipboardImageReceivedFunc_WithClosures :: Maybe ClipboardImageReceivedFunc_WithClosures

wrap_ClipboardImageReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardImageReceivedFunc)) -> ClipboardImageReceivedFunc_WithClosures -> Ptr Clipboard -> Ptr Pixbuf -> Ptr () -> IO ()

ClipboardReceivedFunc

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

type ClipboardReceivedFunc = Clipboard -> SelectionData -> IO ()

type ClipboardReceivedFunc_WithClosures = Clipboard -> SelectionData -> Ptr () -> IO ()

drop_closures_ClipboardReceivedFunc :: ClipboardReceivedFunc -> ClipboardReceivedFunc_WithClosures

dynamic_ClipboardReceivedFunc

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

genClosure_ClipboardReceivedFunc :: ClipboardReceivedFunc -> IO Closure

mk_ClipboardReceivedFunc :: C_ClipboardReceivedFunc -> IO (FunPtr C_ClipboardReceivedFunc)

noClipboardReceivedFunc :: Maybe ClipboardReceivedFunc

noClipboardReceivedFunc_WithClosures :: Maybe ClipboardReceivedFunc_WithClosures

wrap_ClipboardReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardReceivedFunc)) -> ClipboardReceivedFunc_WithClosures -> Ptr Clipboard -> Ptr SelectionData -> Ptr () -> IO ()

ClipboardRichTextReceivedFunc

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

type ClipboardRichTextReceivedFunc = Clipboard -> Atom -> Maybe Text -> Word64 -> IO ()

type ClipboardRichTextReceivedFunc_WithClosures = Clipboard -> Atom -> Maybe Text -> Word64 -> Ptr () -> IO ()

drop_closures_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> ClipboardRichTextReceivedFunc_WithClosures

dynamic_ClipboardRichTextReceivedFunc

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a)

=> FunPtr C_ClipboardRichTextReceivedFunc

-> a

clipboard: the Clipboard

-> Atom

format: The format of the rich text

-> Maybe Text

text: the rich text received, as a UTF-8 encoded string, or Nothing if retrieving the data failed.

-> Word64

length: Length of the text.

-> Ptr ()

data: the userData supplied to clipboardRequestRichText.

-> m ()

genClosure_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> IO Closure

mk_ClipboardRichTextReceivedFunc :: C_ClipboardRichTextReceivedFunc -> IO (FunPtr C_ClipboardRichTextReceivedFunc)

noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc

noClipboardRichTextReceivedFunc_WithClosures :: Maybe ClipboardRichTextReceivedFunc_WithClosures

wrap_ClipboardRichTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardRichTextReceivedFunc)) -> ClipboardRichTextReceivedFunc_WithClosures -> Ptr Clipboard -> Ptr Atom -> CString -> Word64 -> Ptr () -> IO ()

ClipboardTargetsReceivedFunc

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

type ClipboardTargetsReceivedFunc = Clipboard -> Maybe [Atom] -> IO ()

type ClipboardTargetsReceivedFunc_WithClosures = Clipboard -> Maybe [Atom] -> Ptr () -> IO ()

drop_closures_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> ClipboardTargetsReceivedFunc_WithClosures

dynamic_ClipboardTargetsReceivedFunc

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

genClosure_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> IO Closure

mk_ClipboardTargetsReceivedFunc :: C_ClipboardTargetsReceivedFunc -> IO (FunPtr C_ClipboardTargetsReceivedFunc)

noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc

noClipboardTargetsReceivedFunc_WithClosures :: Maybe ClipboardTargetsReceivedFunc_WithClosures

wrap_ClipboardTargetsReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTargetsReceivedFunc)) -> ClipboardTargetsReceivedFunc_WithClosures -> Ptr Clipboard -> Ptr (Ptr Atom) -> Int32 -> Ptr () -> IO ()

ClipboardTextReceivedFunc

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

type ClipboardTextReceivedFunc = Clipboard -> Maybe Text -> IO ()

type ClipboardTextReceivedFunc_WithClosures = Clipboard -> Maybe Text -> Ptr () -> IO ()

drop_closures_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> ClipboardTextReceivedFunc_WithClosures

dynamic_ClipboardTextReceivedFunc

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

genClosure_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> IO Closure

mk_ClipboardTextReceivedFunc :: C_ClipboardTextReceivedFunc -> IO (FunPtr C_ClipboardTextReceivedFunc)

noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc

noClipboardTextReceivedFunc_WithClosures :: Maybe ClipboardTextReceivedFunc_WithClosures

wrap_ClipboardTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTextReceivedFunc)) -> ClipboardTextReceivedFunc_WithClosures -> Ptr Clipboard -> CString -> Ptr () -> IO ()

ClipboardURIReceivedFunc

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

type ClipboardURIReceivedFunc = Clipboard -> [Text] -> IO ()

type ClipboardURIReceivedFunc_WithClosures = Clipboard -> [Text] -> Ptr () -> IO ()

drop_closures_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> ClipboardURIReceivedFunc_WithClosures

dynamic_ClipboardURIReceivedFunc

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

genClosure_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> IO Closure

mk_ClipboardURIReceivedFunc :: C_ClipboardURIReceivedFunc -> IO (FunPtr C_ClipboardURIReceivedFunc)

noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc

noClipboardURIReceivedFunc_WithClosures :: Maybe ClipboardURIReceivedFunc_WithClosures

wrap_ClipboardURIReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardURIReceivedFunc)) -> ClipboardURIReceivedFunc_WithClosures -> Ptr Clipboard -> Ptr CString -> Ptr () -> IO ()

ColorSelectionChangePaletteFunc

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

type ColorSelectionChangePaletteFunc = [Color] -> IO ()

Deprecated: (Since version 3.4)

dynamic_ColorSelectionChangePaletteFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ColorSelectionChangePaletteFunc

-> [Color]

colors: Array of colors

-> m ()

genClosure_ColorSelectionChangePaletteFunc :: ColorSelectionChangePaletteFunc -> IO Closure

mk_ColorSelectionChangePaletteFunc :: C_ColorSelectionChangePaletteFunc -> IO (FunPtr C_ColorSelectionChangePaletteFunc)

noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc

wrap_ColorSelectionChangePaletteFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteFunc)) -> ColorSelectionChangePaletteFunc -> Ptr Color -> Int32 -> IO ()

ColorSelectionChangePaletteWithScreenFunc

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

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

Deprecated: (Since version 3.4)

dynamic_ColorSelectionChangePaletteWithScreenFunc

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> FunPtr C_ColorSelectionChangePaletteWithScreenFunc

-> a

-> [Color]

colors: Array of colors

-> m ()

genClosure_ColorSelectionChangePaletteWithScreenFunc :: ColorSelectionChangePaletteWithScreenFunc -> IO Closure

mk_ColorSelectionChangePaletteWithScreenFunc :: C_ColorSelectionChangePaletteWithScreenFunc -> IO (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)

noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc

wrap_ColorSelectionChangePaletteWithScreenFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)) -> ColorSelectionChangePaletteWithScreenFunc -> Ptr Screen -> Ptr Color -> Int32 -> IO ()

EntryCompletionMatchFunc

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

type EntryCompletionMatchFunc = EntryCompletion -> Text -> TreeIter -> IO Bool

type EntryCompletionMatchFunc_WithClosures = EntryCompletion -> Text -> TreeIter -> Ptr () -> IO Bool

drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures

dynamic_EntryCompletionMatchFunc

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

genClosure_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> IO Closure

mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc)

noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc

noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures

wrap_EntryCompletionMatchFunc :: Maybe (Ptr (FunPtr C_EntryCompletionMatchFunc)) -> EntryCompletionMatchFunc_WithClosures -> Ptr EntryCompletion -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

FileFilterFunc

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

type FileFilterFunc = FileFilterInfo -> IO Bool

type FileFilterFunc_WithClosures = FileFilterInfo -> Ptr () -> IO Bool

drop_closures_FileFilterFunc :: FileFilterFunc -> FileFilterFunc_WithClosures

dynamic_FileFilterFunc

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

genClosure_FileFilterFunc :: FileFilterFunc -> IO Closure

mk_FileFilterFunc :: C_FileFilterFunc -> IO (FunPtr C_FileFilterFunc)

noFileFilterFunc :: Maybe FileFilterFunc

noFileFilterFunc_WithClosures :: Maybe FileFilterFunc_WithClosures

wrap_FileFilterFunc :: Maybe (Ptr (FunPtr C_FileFilterFunc)) -> FileFilterFunc_WithClosures -> Ptr FileFilterInfo -> Ptr () -> IO CInt

FlowBoxCreateWidgetFunc

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

type FlowBoxCreateWidgetFunc = Ptr () -> IO Widget

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

drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures

dynamic_FlowBoxCreateWidgetFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_FlowBoxCreateWidgetFunc

-> Ptr ()

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

genClosure_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> IO Closure

mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc)

noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc

noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures

wrap_FlowBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_FlowBoxCreateWidgetFunc)) -> FlowBoxCreateWidgetFunc_WithClosures -> Ptr () -> Ptr () -> IO (Ptr Widget)

FlowBoxFilterFunc

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

type FlowBoxFilterFunc = FlowBoxChild -> IO Bool

type FlowBoxFilterFunc_WithClosures = FlowBoxChild -> Ptr () -> IO Bool

drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures

dynamic_FlowBoxFilterFunc

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

genClosure_FlowBoxFilterFunc :: FlowBoxFilterFunc -> IO Closure

mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc)

noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc

noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures

wrap_FlowBoxFilterFunc :: Maybe (Ptr (FunPtr C_FlowBoxFilterFunc)) -> FlowBoxFilterFunc_WithClosures -> Ptr FlowBoxChild -> Ptr () -> IO CInt

FlowBoxForeachFunc

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

type FlowBoxForeachFunc = FlowBox -> FlowBoxChild -> IO ()

type FlowBoxForeachFunc_WithClosures = FlowBox -> FlowBoxChild -> Ptr () -> IO ()

drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures

dynamic_FlowBoxForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b)

=> FunPtr C_FlowBoxForeachFunc

-> a

box: a FlowBox

-> b

child: a FlowBoxChild

-> Ptr ()

userData: user data

-> m ()

genClosure_FlowBoxForeachFunc :: FlowBoxForeachFunc -> IO Closure

mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc)

noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc

noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures

wrap_FlowBoxForeachFunc :: Maybe (Ptr (FunPtr C_FlowBoxForeachFunc)) -> FlowBoxForeachFunc_WithClosures -> Ptr FlowBox -> Ptr FlowBoxChild -> Ptr () -> IO ()

FlowBoxSortFunc

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

type FlowBoxSortFunc = FlowBoxChild -> FlowBoxChild -> IO Int32

type FlowBoxSortFunc_WithClosures = FlowBoxChild -> FlowBoxChild -> Ptr () -> IO Int32

drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures

dynamic_FlowBoxSortFunc

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

genClosure_FlowBoxSortFunc :: FlowBoxSortFunc -> IO Closure

mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc)

noFlowBoxSortFunc :: Maybe FlowBoxSortFunc

noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures

wrap_FlowBoxSortFunc :: Maybe (Ptr (FunPtr C_FlowBoxSortFunc)) -> FlowBoxSortFunc_WithClosures -> Ptr FlowBoxChild -> Ptr FlowBoxChild -> Ptr () -> IO Int32

FontFilterFunc

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

type FontFilterFunc = FontFamily -> FontFace -> IO Bool

type FontFilterFunc_WithClosures = FontFamily -> FontFace -> Ptr () -> IO Bool

drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures

dynamic_FontFilterFunc

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

genClosure_FontFilterFunc :: FontFilterFunc -> IO Closure

mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc)

noFontFilterFunc :: Maybe FontFilterFunc

noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures

wrap_FontFilterFunc :: Maybe (Ptr (FunPtr C_FontFilterFunc)) -> FontFilterFunc_WithClosures -> Ptr FontFamily -> Ptr FontFace -> Ptr () -> IO CInt

IconViewForeachFunc

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

type IconViewForeachFunc = IconView -> TreePath -> IO ()

type IconViewForeachFunc_WithClosures = IconView -> TreePath -> Ptr () -> IO ()

drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures

dynamic_IconViewForeachFunc

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

genClosure_IconViewForeachFunc :: IconViewForeachFunc -> IO Closure

mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc)

noIconViewForeachFunc :: Maybe IconViewForeachFunc

noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures

wrap_IconViewForeachFunc :: Maybe (Ptr (FunPtr C_IconViewForeachFunc)) -> IconViewForeachFunc_WithClosures -> Ptr IconView -> Ptr TreePath -> Ptr () -> IO ()

KeySnoopFunc

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

type KeySnoopFunc = Widget -> EventKey -> IO Int32

type KeySnoopFunc_WithClosures = Widget -> EventKey -> Ptr () -> IO Int32

drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures

dynamic_KeySnoopFunc

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.

genClosure_KeySnoopFunc :: KeySnoopFunc -> IO Closure

mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc)

noKeySnoopFunc :: Maybe KeySnoopFunc

noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures

wrap_KeySnoopFunc :: Maybe (Ptr (FunPtr C_KeySnoopFunc)) -> KeySnoopFunc_WithClosures -> Ptr Widget -> Ptr EventKey -> Ptr () -> IO Int32

ListBoxCreateWidgetFunc

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

type ListBoxCreateWidgetFunc = Object -> IO Widget

type ListBoxCreateWidgetFunc_WithClosures = Object -> Ptr () -> IO Widget

drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures

dynamic_ListBoxCreateWidgetFunc

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

genClosure_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> IO Closure

mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc)

noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc

noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures

wrap_ListBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_ListBoxCreateWidgetFunc)) -> ListBoxCreateWidgetFunc_WithClosures -> Ptr Object -> Ptr () -> IO (Ptr Widget)

ListBoxFilterFunc

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

type ListBoxFilterFunc = ListBoxRow -> IO Bool

type ListBoxFilterFunc_WithClosures = ListBoxRow -> Ptr () -> IO Bool

drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures

dynamic_ListBoxFilterFunc

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

genClosure_ListBoxFilterFunc :: ListBoxFilterFunc -> IO Closure

mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc)

noListBoxFilterFunc :: Maybe ListBoxFilterFunc

noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures

wrap_ListBoxFilterFunc :: Maybe (Ptr (FunPtr C_ListBoxFilterFunc)) -> ListBoxFilterFunc_WithClosures -> Ptr ListBoxRow -> Ptr () -> IO CInt

ListBoxForeachFunc

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

type ListBoxForeachFunc = ListBox -> ListBoxRow -> IO ()

type ListBoxForeachFunc_WithClosures = ListBox -> ListBoxRow -> Ptr () -> IO ()

drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures

dynamic_ListBoxForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b)

=> FunPtr C_ListBoxForeachFunc

-> a

box: a ListBox

-> b

row: a ListBoxRow

-> Ptr ()

userData: user data

-> m ()

genClosure_ListBoxForeachFunc :: ListBoxForeachFunc -> IO Closure

mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc)

noListBoxForeachFunc :: Maybe ListBoxForeachFunc

noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures

wrap_ListBoxForeachFunc :: Maybe (Ptr (FunPtr C_ListBoxForeachFunc)) -> ListBoxForeachFunc_WithClosures -> Ptr ListBox -> Ptr ListBoxRow -> Ptr () -> IO ()

ListBoxSortFunc

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

type ListBoxSortFunc = ListBoxRow -> ListBoxRow -> IO Int32

type ListBoxSortFunc_WithClosures = ListBoxRow -> ListBoxRow -> Ptr () -> IO Int32

drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures

dynamic_ListBoxSortFunc

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

genClosure_ListBoxSortFunc :: ListBoxSortFunc -> IO Closure

mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc)

noListBoxSortFunc :: Maybe ListBoxSortFunc

noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures

wrap_ListBoxSortFunc :: Maybe (Ptr (FunPtr C_ListBoxSortFunc)) -> ListBoxSortFunc_WithClosures -> Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO Int32

ListBoxUpdateHeaderFunc

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

type ListBoxUpdateHeaderFunc = ListBoxRow -> Maybe ListBoxRow -> IO ()

type ListBoxUpdateHeaderFunc_WithClosures = ListBoxRow -> Maybe ListBoxRow -> Ptr () -> IO ()

drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures

dynamic_ListBoxUpdateHeaderFunc

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

genClosure_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> IO Closure

mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc)

noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc

noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures

wrap_ListBoxUpdateHeaderFunc :: Maybe (Ptr (FunPtr C_ListBoxUpdateHeaderFunc)) -> ListBoxUpdateHeaderFunc_WithClosures -> Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO ()

MenuDetachFunc

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

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

dynamic_MenuDetachFunc

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

genClosure_MenuDetachFunc :: MenuDetachFunc -> IO Closure

mk_MenuDetachFunc :: C_MenuDetachFunc -> IO (FunPtr C_MenuDetachFunc)

noMenuDetachFunc :: Maybe MenuDetachFunc

wrap_MenuDetachFunc :: Maybe (Ptr (FunPtr C_MenuDetachFunc)) -> MenuDetachFunc -> Ptr Widget -> Ptr Menu -> IO ()

MenuPositionFunc

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

type MenuPositionFunc = Menu -> Int32 -> Int32 -> IO (Int32, Int32, Bool)

type MenuPositionFunc_WithClosures = Menu -> Int32 -> Int32 -> Ptr () -> IO (Int32, Int32, Bool)

drop_closures_MenuPositionFunc :: MenuPositionFunc -> MenuPositionFunc_WithClosures

dynamic_MenuPositionFunc

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)

genClosure_MenuPositionFunc :: MenuPositionFunc -> IO Closure

mk_MenuPositionFunc :: C_MenuPositionFunc -> IO (FunPtr C_MenuPositionFunc)

noMenuPositionFunc :: Maybe MenuPositionFunc

noMenuPositionFunc_WithClosures :: Maybe MenuPositionFunc_WithClosures

wrap_MenuPositionFunc :: Maybe (Ptr (FunPtr C_MenuPositionFunc)) -> MenuPositionFunc_WithClosures -> Ptr Menu -> Ptr Int32 -> Ptr Int32 -> Ptr CInt -> Ptr () -> IO ()

ModuleDisplayInitFunc

type C_ModuleDisplayInitFunc = Ptr Display -> IO ()

type ModuleDisplayInitFunc = Display -> IO ()

dynamic_ModuleDisplayInitFunc

Arguments

:: (HasCallStack, MonadIO m, IsDisplay a)

=> FunPtr C_ModuleDisplayInitFunc

-> a

display: an open Display

-> m ()

genClosure_ModuleDisplayInitFunc :: ModuleDisplayInitFunc -> IO Closure

mk_ModuleDisplayInitFunc :: C_ModuleDisplayInitFunc -> IO (FunPtr C_ModuleDisplayInitFunc)

noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc

wrap_ModuleDisplayInitFunc :: Maybe (Ptr (FunPtr C_ModuleDisplayInitFunc)) -> ModuleDisplayInitFunc -> Ptr Display -> IO ()

ModuleInitFunc

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

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

dynamic_ModuleInitFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ModuleInitFunc

-> Maybe [Text]

argv: GTK+ always passes Nothing for this argument

-> m ()

genClosure_ModuleInitFunc :: ModuleInitFunc -> IO Closure

mk_ModuleInitFunc :: C_ModuleInitFunc -> IO (FunPtr C_ModuleInitFunc)

noModuleInitFunc :: Maybe ModuleInitFunc

wrap_ModuleInitFunc :: Maybe (Ptr (FunPtr C_ModuleInitFunc)) -> ModuleInitFunc -> Int32 -> Ptr CString -> IO ()

PageSetupDoneFunc

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

type PageSetupDoneFunc = PageSetup -> IO ()

type PageSetupDoneFunc_WithClosures = PageSetup -> Ptr () -> IO ()

drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures

dynamic_PageSetupDoneFunc

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

genClosure_PageSetupDoneFunc :: PageSetupDoneFunc -> IO Closure

mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc)

noPageSetupDoneFunc :: Maybe PageSetupDoneFunc

noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures

wrap_PageSetupDoneFunc :: Maybe (Ptr (FunPtr C_PageSetupDoneFunc)) -> PageSetupDoneFunc_WithClosures -> Ptr PageSetup -> Ptr () -> IO ()

PrintSettingsFunc

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

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

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

drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures

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

genClosure_PrintSettingsFunc :: PrintSettingsFunc -> IO Closure

mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc)

noPrintSettingsFunc :: Maybe PrintSettingsFunc

noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures

wrap_PrintSettingsFunc :: Maybe (Ptr (FunPtr C_PrintSettingsFunc)) -> PrintSettingsFunc_WithClosures -> CString -> CString -> Ptr () -> IO ()

RcPropertyParser

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

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

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

genClosure_RcPropertyParser :: RcPropertyParser -> IO Closure

mk_RcPropertyParser :: C_RcPropertyParser -> IO (FunPtr C_RcPropertyParser)

noRcPropertyParser :: Maybe RcPropertyParser

wrap_RcPropertyParser :: Maybe (Ptr (FunPtr C_RcPropertyParser)) -> RcPropertyParser -> Ptr GParamSpec -> Ptr String -> Ptr GValue -> IO CInt

RecentFilterFunc

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

type RecentFilterFunc = RecentFilterInfo -> IO Bool

type RecentFilterFunc_WithClosures = RecentFilterInfo -> Ptr () -> IO Bool

drop_closures_RecentFilterFunc :: RecentFilterFunc -> RecentFilterFunc_WithClosures

dynamic_RecentFilterFunc

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

genClosure_RecentFilterFunc :: RecentFilterFunc -> IO Closure

mk_RecentFilterFunc :: C_RecentFilterFunc -> IO (FunPtr C_RecentFilterFunc)

noRecentFilterFunc :: Maybe RecentFilterFunc

noRecentFilterFunc_WithClosures :: Maybe RecentFilterFunc_WithClosures

wrap_RecentFilterFunc :: Maybe (Ptr (FunPtr C_RecentFilterFunc)) -> RecentFilterFunc_WithClosures -> Ptr RecentFilterInfo -> Ptr () -> IO CInt

RecentSortFunc

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

type RecentSortFunc = RecentInfo -> RecentInfo -> IO Int32

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

drop_closures_RecentSortFunc :: RecentSortFunc -> RecentSortFunc_WithClosures

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

genClosure_RecentSortFunc :: RecentSortFunc -> IO Closure

mk_RecentSortFunc :: C_RecentSortFunc -> IO (FunPtr C_RecentSortFunc)

noRecentSortFunc :: Maybe RecentSortFunc

noRecentSortFunc_WithClosures :: Maybe RecentSortFunc_WithClosures

wrap_RecentSortFunc :: Maybe (Ptr (FunPtr C_RecentSortFunc)) -> RecentSortFunc_WithClosures -> Ptr RecentInfo -> Ptr RecentInfo -> Ptr () -> IO Int32

StylePropertyParser

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

type StylePropertyParser = Text -> GValue -> IO ()

dynamic_StylePropertyParser

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_StylePropertyParser

-> Text

-> GValue

-> m ()

(Can throw GError)

mk_StylePropertyParser :: C_StylePropertyParser -> IO (FunPtr C_StylePropertyParser)

noStylePropertyParser :: Maybe StylePropertyParser

TextBufferDeserializeFunc

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

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

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

drop_closures_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> TextBufferDeserializeFunc_WithClosures

dynamic_TextBufferDeserializeFunc

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)

mk_TextBufferDeserializeFunc :: C_TextBufferDeserializeFunc -> IO (FunPtr C_TextBufferDeserializeFunc)

noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc

noTextBufferDeserializeFunc_WithClosures :: Maybe TextBufferDeserializeFunc_WithClosures

TextBufferSerializeFunc

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

type TextBufferSerializeFunc = TextBuffer -> TextBuffer -> TextIter -> TextIter -> Word64 -> IO Word8

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

drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures

dynamic_TextBufferSerializeFunc

Arguments

:: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b)

=> FunPtr C_TextBufferSerializeFunc

-> a

registerBuffer: the TextBuffer for which the format is registered

-> b

contentBuffer: the TextBuffer to serialize

-> TextIter

start: start of the block of text to serialize

-> TextIter

end: end of the block of text to serialize

-> Word64

length: Return location for the length of the serialized data

-> Ptr ()

userData: user data that was specified when registering the format

-> m Word8

Returns: a newly-allocated array of guint8 which contains the serialized data, or Nothing if an error occurred

genClosure_TextBufferSerializeFunc :: TextBufferSerializeFunc -> IO Closure

mk_TextBufferSerializeFunc :: C_TextBufferSerializeFunc -> IO (FunPtr C_TextBufferSerializeFunc)

noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc

noTextBufferSerializeFunc_WithClosures :: Maybe TextBufferSerializeFunc_WithClosures

wrap_TextBufferSerializeFunc :: Maybe (Ptr (FunPtr C_TextBufferSerializeFunc)) -> TextBufferSerializeFunc_WithClosures -> Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr TextIter -> Word64 -> Ptr () -> IO Word8

TextCharPredicate

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

type TextCharPredicate = Char -> IO Bool

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

drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures

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

genClosure_TextCharPredicate :: TextCharPredicate -> IO Closure

mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate)

noTextCharPredicate :: Maybe TextCharPredicate

noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures

wrap_TextCharPredicate :: Maybe (Ptr (FunPtr C_TextCharPredicate)) -> TextCharPredicate_WithClosures -> CInt -> Ptr () -> IO CInt

TextTagTableForeach

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

type TextTagTableForeach = TextTag -> IO ()

type TextTagTableForeach_WithClosures = TextTag -> Ptr () -> IO ()

drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures

dynamic_TextTagTableForeach

Arguments

:: (HasCallStack, MonadIO m, IsTextTag a)

=> FunPtr C_TextTagTableForeach

-> a

tag: the TextTag

-> Ptr ()

data: data passed to textTagTableForeach

-> m ()

genClosure_TextTagTableForeach :: TextTagTableForeach -> IO Closure

mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)

noTextTagTableForeach :: Maybe TextTagTableForeach

noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures

wrap_TextTagTableForeach :: Maybe (Ptr (FunPtr C_TextTagTableForeach)) -> TextTagTableForeach_WithClosures -> Ptr TextTag -> Ptr () -> IO ()

TickCallback

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

type TickCallback = Widget -> FrameClock -> IO Bool

type TickCallback_WithClosures = Widget -> FrameClock -> Ptr () -> IO Bool

drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures

dynamic_TickCallback

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.

genClosure_TickCallback :: TickCallback -> IO Closure

mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback)

noTickCallback :: Maybe TickCallback

noTickCallback_WithClosures :: Maybe TickCallback_WithClosures

wrap_TickCallback :: Maybe (Ptr (FunPtr C_TickCallback)) -> TickCallback_WithClosures -> Ptr Widget -> Ptr FrameClock -> Ptr () -> IO CInt

TranslateFunc

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

type TranslateFunc = Text -> IO Text

Deprecated: (Since version 3.10)

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

drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures

dynamic_TranslateFunc

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

genClosure_TranslateFunc :: TranslateFunc -> IO Closure

mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc)

noTranslateFunc :: Maybe TranslateFunc

noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures

wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc_WithClosures -> CString -> Ptr () -> IO CString

TreeCellDataFunc

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

type TreeCellDataFunc = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> IO ()

type TreeCellDataFunc_WithClosures = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()

drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures

dynamic_TreeCellDataFunc

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

genClosure_TreeCellDataFunc :: TreeCellDataFunc -> IO Closure

mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)

noTreeCellDataFunc :: Maybe TreeCellDataFunc

noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures

wrap_TreeCellDataFunc :: Maybe (Ptr (FunPtr C_TreeCellDataFunc)) -> TreeCellDataFunc_WithClosures -> Ptr TreeViewColumn -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

TreeDestroyCountFunc

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

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

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

drop_closures_TreeDestroyCountFunc :: TreeDestroyCountFunc -> TreeDestroyCountFunc_WithClosures

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

genClosure_TreeDestroyCountFunc :: TreeDestroyCountFunc -> IO Closure

mk_TreeDestroyCountFunc :: C_TreeDestroyCountFunc -> IO (FunPtr C_TreeDestroyCountFunc)

noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc

noTreeDestroyCountFunc_WithClosures :: Maybe TreeDestroyCountFunc_WithClosures

wrap_TreeDestroyCountFunc :: Maybe (Ptr (FunPtr C_TreeDestroyCountFunc)) -> TreeDestroyCountFunc_WithClosures -> Ptr TreeView -> Ptr TreePath -> Int32 -> Ptr () -> IO ()

TreeIterCompareFunc

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

type TreeIterCompareFunc = TreeModel -> TreeIter -> TreeIter -> IO Int32

type TreeIterCompareFunc_WithClosures = TreeModel -> TreeIter -> TreeIter -> Ptr () -> IO Int32

drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures

dynamic_TreeIterCompareFunc

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

genClosure_TreeIterCompareFunc :: TreeIterCompareFunc -> IO Closure

mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)

noTreeIterCompareFunc :: Maybe TreeIterCompareFunc

noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures

wrap_TreeIterCompareFunc :: Maybe (Ptr (FunPtr C_TreeIterCompareFunc)) -> TreeIterCompareFunc_WithClosures -> Ptr TreeModel -> Ptr TreeIter -> Ptr TreeIter -> Ptr () -> IO Int32

TreeModelFilterVisibleFunc

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

type TreeModelFilterVisibleFunc = TreeModel -> TreeIter -> IO Bool

type TreeModelFilterVisibleFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool

drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures

dynamic_TreeModelFilterVisibleFunc

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.

genClosure_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> IO Closure

mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)

noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc

noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures

wrap_TreeModelFilterVisibleFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc)) -> TreeModelFilterVisibleFunc_WithClosures -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

TreeModelForeachFunc

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

type TreeModelForeachFunc = TreeModel -> TreePath -> TreeIter -> IO Bool

type TreeModelForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO Bool

drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures

dynamic_TreeModelForeachFunc

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

genClosure_TreeModelForeachFunc :: TreeModelForeachFunc -> IO Closure

mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)

noTreeModelForeachFunc :: Maybe TreeModelForeachFunc

noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures

wrap_TreeModelForeachFunc :: Maybe (Ptr (FunPtr C_TreeModelForeachFunc)) -> TreeModelForeachFunc_WithClosures -> Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt

TreeSelectionForeachFunc

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

type TreeSelectionForeachFunc = TreeModel -> TreePath -> TreeIter -> IO ()

type TreeSelectionForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO ()

drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures

dynamic_TreeSelectionForeachFunc

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

genClosure_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> IO Closure

mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)

noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc

noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures

wrap_TreeSelectionForeachFunc :: Maybe (Ptr (FunPtr C_TreeSelectionForeachFunc)) -> TreeSelectionForeachFunc_WithClosures -> Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()

TreeSelectionFunc

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

type TreeSelectionFunc = TreeSelection -> TreeModel -> TreePath -> Bool -> IO Bool

type TreeSelectionFunc_WithClosures = TreeSelection -> TreeModel -> TreePath -> Bool -> Ptr () -> IO Bool

drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures

dynamic_TreeSelectionFunc

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

genClosure_TreeSelectionFunc :: TreeSelectionFunc -> IO Closure

mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)

noTreeSelectionFunc :: Maybe TreeSelectionFunc

noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures

wrap_TreeSelectionFunc :: Maybe (Ptr (FunPtr C_TreeSelectionFunc)) -> TreeSelectionFunc_WithClosures -> Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt

TreeViewColumnDropFunc

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

type TreeViewColumnDropFunc = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> IO Bool

type TreeViewColumnDropFunc_WithClosures = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> Ptr () -> IO Bool

drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures

dynamic_TreeViewColumnDropFunc

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

genClosure_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> IO Closure

mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)

noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc

noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures

wrap_TreeViewColumnDropFunc :: Maybe (Ptr (FunPtr C_TreeViewColumnDropFunc)) -> TreeViewColumnDropFunc_WithClosures -> Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt

TreeViewMappingFunc

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

type TreeViewMappingFunc = TreeView -> TreePath -> IO ()

type TreeViewMappingFunc_WithClosures = TreeView -> TreePath -> Ptr () -> IO ()

drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures

dynamic_TreeViewMappingFunc

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

genClosure_TreeViewMappingFunc :: TreeViewMappingFunc -> IO Closure

mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)

noTreeViewMappingFunc :: Maybe TreeViewMappingFunc

noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures

wrap_TreeViewMappingFunc :: Maybe (Ptr (FunPtr C_TreeViewMappingFunc)) -> TreeViewMappingFunc_WithClosures -> Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()

TreeViewRowSeparatorFunc

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

type TreeViewRowSeparatorFunc = TreeModel -> TreeIter -> IO Bool

type TreeViewRowSeparatorFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool

drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures

dynamic_TreeViewRowSeparatorFunc

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

genClosure_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> IO Closure

mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)

noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc

noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures

wrap_TreeViewRowSeparatorFunc :: Maybe (Ptr (FunPtr C_TreeViewRowSeparatorFunc)) -> TreeViewRowSeparatorFunc_WithClosures -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

TreeViewSearchEqualFunc

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

type TreeViewSearchEqualFunc = TreeModel -> Int32 -> Text -> TreeIter -> IO Bool

type TreeViewSearchEqualFunc_WithClosures = TreeModel -> Int32 -> Text -> TreeIter -> Ptr () -> IO Bool

drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures

dynamic_TreeViewSearchEqualFunc

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.

genClosure_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> IO Closure

mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)

noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc

noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures

wrap_TreeViewSearchEqualFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchEqualFunc)) -> TreeViewSearchEqualFunc_WithClosures -> Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

TreeViewSearchPositionFunc

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

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

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

drop_closures_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> TreeViewSearchPositionFunc_WithClosures

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

genClosure_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> IO Closure

mk_TreeViewSearchPositionFunc :: C_TreeViewSearchPositionFunc -> IO (FunPtr C_TreeViewSearchPositionFunc)

noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc

noTreeViewSearchPositionFunc_WithClosures :: Maybe TreeViewSearchPositionFunc_WithClosures

wrap_TreeViewSearchPositionFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchPositionFunc)) -> TreeViewSearchPositionFunc_WithClosures -> Ptr TreeView -> Ptr Widget -> Ptr () -> IO ()