gi-gtk-3.0.27: Gtk bindings

CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria (garetxe@gmail.com)
Safe HaskellNone
LanguageHaskell2010

GI.Gtk.Callbacks

Contents

Description

 
Synopsis

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.

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

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

AccelGroupFindFunc

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

No description available in the introspection data.

Since: 2.2

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

No description available in the introspection data.

Since: 2.2

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

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

drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

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

Generate a function pointer callable from C code, from 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.

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

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

AssistantPageFunc

type AssistantPageFunc Source #

Arguments

 = Int32

currentPage: The page number used to calculate the next page.

-> IO Int32

Returns: The next page number.

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

type AssistantPageFunc_WithClosures Source #

Arguments

 = Int32

currentPage: The page number used to calculate the next page.

-> Ptr ()

data: user data.

-> IO Int32

Returns: The next page number.

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

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

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

drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_AssistantPageFunc Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> FunPtr C_AssistantPageFunc 
-> Int32

currentPage: The page number used to calculate the next page.

-> Ptr ()

data: user data.

-> m Int32

Returns: The next page number.

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

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

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

Callback

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

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

type Callback Source #

Arguments

 = Widget

widget: the widget to operate on

-> IO () 

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

type Callback_WithClosures Source #

Arguments

 = Widget

widget: the widget to operate on

-> Ptr ()

data: user-supplied data

-> IO () 

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

drop_closures_Callback :: Callback -> Callback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_Callback Source #

Arguments

:: (HasCallStack, MonadIO m, IsWidget a) 
=> FunPtr C_Callback 
-> a

widget: the widget to operate on

-> Ptr ()

data: user-supplied data

-> m () 

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

genClosure_Callback :: Callback -> IO Closure Source #

Wrap the callback into a Closure.

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

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

noCallback :: Maybe Callback Source #

A convenience synonym for Nothing :: Maybe Callback.

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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

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

ClipboardImageReceivedFunc

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

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

type ClipboardImageReceivedFunc Source #

Arguments

 = Clipboard

clipboard: the Clipboard

-> Pixbuf

pixbuf: the received image

-> IO () 

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

Since: 2.6

type ClipboardImageReceivedFunc_WithClosures Source #

Arguments

 = Clipboard

clipboard: the Clipboard

-> Pixbuf

pixbuf: the received image

-> Ptr ()

data: the userData supplied to clipboardRequestImage.

-> IO () 

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

Since: 2.6

dynamic_ClipboardImageReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b) 
=> FunPtr C_ClipboardImageReceivedFunc 
-> a

clipboard: the Clipboard

-> b

pixbuf: the received image

-> Ptr ()

data: the userData supplied to clipboardRequestImage.

-> m () 

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

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.

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.

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

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

ClipboardRichTextReceivedFunc

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

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

type ClipboardRichTextReceivedFunc Source #

Arguments

 = Clipboard

clipboard: the Clipboard

-> Atom

format: The format of the rich text

-> Maybe Text

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

-> Word64

length: Length of the text.

-> IO () 

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

Since: 2.10

type ClipboardRichTextReceivedFunc_WithClosures Source #

Arguments

 = Clipboard

clipboard: the Clipboard

-> Atom

format: The format of the rich text

-> Maybe Text

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

-> Word64

length: Length of the text.

-> Ptr ()

data: the userData supplied to clipboardRequestRichText.

-> IO () 

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

Since: 2.10

dynamic_ClipboardRichTextReceivedFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsClipboard a) 
=> FunPtr C_ClipboardRichTextReceivedFunc 
-> a

clipboard: the Clipboard

-> Atom

format: The format of the rich text

-> Maybe Text

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

-> Word64

length: Length of the text.

-> Ptr ()

data: the userData supplied to clipboardRequestRichText.

-> m () 

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

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

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.

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.

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.

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

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.

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.

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.

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

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.

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.

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

Generate a function pointer callable from C code, from 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

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.

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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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

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.

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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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

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.

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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

TextBufferDeserializeFunc

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

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

type TextBufferDeserializeFunc Source #

Arguments

 = TextBuffer

registerBuffer: the TextBuffer the format is registered with

-> TextBuffer

contentBuffer: the TextBuffer to deserialize into

-> TextIter

iter: insertion point for the deserialized text

-> ByteString

data: data to deserialize

-> Bool

createTags: True if deserializing may create tags

-> IO ()

Returns: True on success, False otherwise (Can throw GError)

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

type TextBufferDeserializeFunc_WithClosures Source #

Arguments

 = TextBuffer

registerBuffer: the TextBuffer the format is registered with

-> TextBuffer

contentBuffer: the TextBuffer to deserialize into

-> TextIter

iter: insertion point for the deserialized text

-> ByteString

data: data to deserialize

-> Bool

createTags: True if deserializing may create tags

-> Ptr ()

userData: user data that was specified when registering the format

-> IO ()

Returns: True on success, False otherwise (Can throw GError)

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

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.

TextBufferSerializeFunc

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

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

type TextBufferSerializeFunc Source #

Arguments

 = TextBuffer

registerBuffer: the TextBuffer for which the format is registered

-> TextBuffer

contentBuffer: the TextBuffer to serialize

-> TextIter

start: start of the block of text to serialize

-> TextIter

end: end of the block of text to serialize

-> Word64

length: Return location for the length of the serialized data

-> IO Word8

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

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

type TextBufferSerializeFunc_WithClosures Source #

Arguments

 = TextBuffer

registerBuffer: the TextBuffer for which the format is registered

-> TextBuffer

contentBuffer: the TextBuffer to serialize

-> TextIter

start: start of the block of text to serialize

-> TextIter

end: end of the block of text to serialize

-> Word64

length: Return location for the length of the serialized data

-> Ptr ()

userData: user data that was specified when registering the format

-> IO Word8

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

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

dynamic_TextBufferSerializeFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) 
=> FunPtr C_TextBufferSerializeFunc 
-> a

registerBuffer: the TextBuffer for which the format is registered

-> b

contentBuffer: the TextBuffer to serialize

-> TextIter

start: start of the block of text to serialize

-> TextIter

end: end of the block of text to serialize

-> Word64

length: Return location for the length of the serialized data

-> Ptr ()

userData: user data that was specified when registering the format

-> m Word8

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

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

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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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

Generate a function pointer callable from C code, from 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.

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.

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

Generate a function pointer callable from C code, from 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.

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

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

TreeModelFilterVisibleFunc

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

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

type TreeModelFilterVisibleFunc Source #

Arguments

 = TreeModel

model: the child model of the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row in model whose visibility is determined

-> IO Bool

Returns: Whether the row indicated by iter is visible.

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

type TreeModelFilterVisibleFunc_WithClosures Source #

Arguments

 = TreeModel

model: the child model of the TreeModelFilter

-> TreeIter

iter: a TreeIter pointing to the row in model whose visibility is determined

-> Ptr ()

data: user data given to treeModelFilterSetVisibleFunc

-> IO Bool

Returns: Whether the row indicated by iter is visible.

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

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.

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.

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.

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

Generate a function pointer callable from C code, from 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.

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.

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.

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

Generate a function pointer callable from C code, from 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.

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.

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.

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

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