gi-gtk-3.0.32: Gtk bindings
CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria
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 -> GClosure () -> IO Bool Source #

No description available in the introspection data.

Since: 2.2

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

No description available in the introspection data.

Since: 2.2

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

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

drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

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

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

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

Wrap the callback into a GClosure.

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

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

noCallback :: Maybe Callback Source #

A convenience synonym for Nothing :: Maybe Callback.

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.

ContainerClassAddFieldCallback

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

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

type ContainerClassAddFieldCallback Source #

Arguments

 = Container

container: a Container

-> Widget

widget: a widget to be placed inside container

-> IO () 

No description available in the introspection data.

dynamic_ContainerClassAddFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) 
=> FunPtr C_ContainerClassAddFieldCallback 
-> a

container: a Container

-> b

widget: a widget to be placed inside container

-> m () 

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

ContainerClassCheckResizeFieldCallback

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

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

type ContainerClassCheckResizeFieldCallback = Container -> IO () Source #

No description available in the introspection data.

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

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