gi-gtk-3.0.33: 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