GI.Gdk.Callbacks

Signals

EventFunc

type C_EventFunc = Ptr Event -> Ptr () -> IO ()

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

type EventFunc

Arguments

 = Event

event: the Event to process.

-> IO ()

Specifies the type of function passed to eventHandlerSet to handle all GDK events.

type EventFunc_WithClosures

Arguments

 = Event

event: the Event to process.

-> Ptr ()

data: user data set when the event handler was installed with eventHandlerSet.

-> IO ()

Specifies the type of function passed to eventHandlerSet to handle all GDK events.

drop_closures_EventFunc :: EventFunc -> EventFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_EventFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_EventFunc

-> Event

event: the Event to process.

-> Ptr ()

data: user data set when the event handler was installed with eventHandlerSet.

-> m ()

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

genClosure_EventFunc :: EventFunc -> IO Closure

Wrap the callback into a Closure.

mk_EventFunc :: C_EventFunc -> IO (FunPtr C_EventFunc)

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

noEventFunc :: Maybe EventFunc

A convenience synonym for Nothing :: Maybe EventFunc.

noEventFunc_WithClosures :: Maybe EventFunc_WithClosures

A convenience synonym for Nothing :: Maybe EventFunc_WithClosures.

wrap_EventFunc :: Maybe (Ptr (FunPtr C_EventFunc)) -> EventFunc_WithClosures -> C_EventFunc

Wrap a EventFunc into a C_EventFunc.

FilterFunc

type C_FilterFunc = Ptr () -> Ptr Event -> Ptr () -> IO CUInt

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

type FilterFunc

Arguments

 = Ptr ()

xevent: the native event to filter.

-> Event

event: the GDK event to which the X event will be translated.

-> IO FilterReturn

Returns: a FilterReturn value.

Specifies the type of function used to filter native events before they are converted to GDK events.

When a filter is called, event is unpopulated, except for event->window. The filter may translate the native event to a GDK event and store the result in event, or handle it without translation. If the filter translates the event and processing should continue, it should return FilterReturnTranslate.

type FilterFunc_WithClosures

Arguments

 = Ptr ()

xevent: the native event to filter.

-> Event

event: the GDK event to which the X event will be translated.

-> Ptr ()

data: user data set when the filter was installed.

-> IO FilterReturn

Returns: a FilterReturn value.

Specifies the type of function used to filter native events before they are converted to GDK events.

When a filter is called, event is unpopulated, except for event->window. The filter may translate the native event to a GDK event and store the result in event, or handle it without translation. If the filter translates the event and processing should continue, it should return FilterReturnTranslate.

drop_closures_FilterFunc :: FilterFunc -> FilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_FilterFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_FilterFunc

-> Ptr ()

xevent: the native event to filter.

-> Event

event: the GDK event to which the X event will be translated.

-> Ptr ()

data: user data set when the filter was installed.

-> m FilterReturn

Returns: a FilterReturn value.

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

genClosure_FilterFunc :: FilterFunc -> IO Closure

Wrap the callback into a Closure.

mk_FilterFunc :: C_FilterFunc -> IO (FunPtr C_FilterFunc)

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

noFilterFunc :: Maybe FilterFunc

A convenience synonym for Nothing :: Maybe FilterFunc.

noFilterFunc_WithClosures :: Maybe FilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe FilterFunc_WithClosures.

wrap_FilterFunc :: Maybe (Ptr (FunPtr C_FilterFunc)) -> FilterFunc_WithClosures -> C_FilterFunc

Wrap a FilterFunc into a C_FilterFunc.

SeatGrabPrepareFunc

type C_SeatGrabPrepareFunc = Ptr Seat -> Ptr Window -> Ptr () -> IO ()

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

type SeatGrabPrepareFunc

Arguments

 = Seat

seat: the Seat being grabbed

-> Window

window: the Window being grabbed

-> IO ()

Type of the callback used to set up window so it can be grabbed. A typical action would be ensuring the window is visible, although there's room for other initialization actions.

Since: 3.20

type SeatGrabPrepareFunc_WithClosures

Arguments

 = Seat

seat: the Seat being grabbed

-> Window

window: the Window being grabbed

-> Ptr ()

userData: user data passed in seatGrab

-> IO ()

Type of the callback used to set up window so it can be grabbed. A typical action would be ensuring the window is visible, although there's room for other initialization actions.

Since: 3.20

drop_closures_SeatGrabPrepareFunc :: SeatGrabPrepareFunc -> SeatGrabPrepareFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SeatGrabPrepareFunc

Arguments

:: (HasCallStack, MonadIO m, IsSeat a, IsWindow b)

=> FunPtr C_SeatGrabPrepareFunc

-> a

seat: the Seat being grabbed

-> b

window: the Window being grabbed

-> Ptr ()

userData: user data passed in seatGrab

-> m ()

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

genClosure_SeatGrabPrepareFunc :: SeatGrabPrepareFunc -> IO Closure

Wrap the callback into a Closure.

mk_SeatGrabPrepareFunc :: C_SeatGrabPrepareFunc -> IO (FunPtr C_SeatGrabPrepareFunc)

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

noSeatGrabPrepareFunc :: Maybe SeatGrabPrepareFunc

A convenience synonym for Nothing :: Maybe SeatGrabPrepareFunc.

noSeatGrabPrepareFunc_WithClosures :: Maybe SeatGrabPrepareFunc_WithClosures

A convenience synonym for Nothing :: Maybe SeatGrabPrepareFunc_WithClosures.

wrap_SeatGrabPrepareFunc :: Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc)) -> SeatGrabPrepareFunc_WithClosures -> C_SeatGrabPrepareFunc

Wrap a SeatGrabPrepareFunc into a C_SeatGrabPrepareFunc.

WindowChildFunc

type C_WindowChildFunc = Ptr Window -> Ptr () -> IO CInt

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

type WindowChildFunc

Arguments

 = Window

window: a Window

-> IO Bool

Returns: True to invalidate window recursively

A function of this type is passed to windowInvalidateMaybeRecurse. It gets called for each child of the window to determine whether to recursively invalidate it or now.

type WindowChildFunc_WithClosures

Arguments

 = Window

window: a Window

-> Ptr ()

userData: user data

-> IO Bool

Returns: True to invalidate window recursively

A function of this type is passed to windowInvalidateMaybeRecurse. It gets called for each child of the window to determine whether to recursively invalidate it or now.

drop_closures_WindowChildFunc :: WindowChildFunc -> WindowChildFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_WindowChildFunc

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> FunPtr C_WindowChildFunc

-> a

window: a Window

-> Ptr ()

userData: user data

-> m Bool

Returns: True to invalidate window recursively

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

genClosure_WindowChildFunc :: WindowChildFunc -> IO Closure

Wrap the callback into a Closure.

mk_WindowChildFunc :: C_WindowChildFunc -> IO (FunPtr C_WindowChildFunc)

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

noWindowChildFunc :: Maybe WindowChildFunc

A convenience synonym for Nothing :: Maybe WindowChildFunc.

noWindowChildFunc_WithClosures :: Maybe WindowChildFunc_WithClosures

A convenience synonym for Nothing :: Maybe WindowChildFunc_WithClosures.

wrap_WindowChildFunc :: Maybe (Ptr (FunPtr C_WindowChildFunc)) -> WindowChildFunc_WithClosures -> C_WindowChildFunc

Wrap a WindowChildFunc into a C_WindowChildFunc.

WindowInvalidateHandlerFunc

type C_WindowInvalidateHandlerFunc = Ptr Window -> Ptr Region -> IO ()

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

type WindowInvalidateHandlerFunc

Arguments

 = Window

window: a Window

-> Region

region: a Region

-> IO ()

Whenever some area of the window is invalidated (directly in the window or in a child window) this gets called with region in the coordinate space of window. You can use region to just keep track of the dirty region, or you can actually change region in case you are doing display tricks like showing a child in multiple places.

Since: 3.10

dynamic_WindowInvalidateHandlerFunc

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> FunPtr C_WindowInvalidateHandlerFunc

-> a

window: a Window

-> Region

region: a Region

-> m ()

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

genClosure_WindowInvalidateHandlerFunc :: WindowInvalidateHandlerFunc -> IO Closure

Wrap the callback into a Closure.

mk_WindowInvalidateHandlerFunc :: C_WindowInvalidateHandlerFunc -> IO (FunPtr C_WindowInvalidateHandlerFunc)

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

noWindowInvalidateHandlerFunc :: Maybe WindowInvalidateHandlerFunc

A convenience synonym for Nothing :: Maybe WindowInvalidateHandlerFunc.

wrap_WindowInvalidateHandlerFunc :: Maybe (Ptr (FunPtr C_WindowInvalidateHandlerFunc)) -> WindowInvalidateHandlerFunc -> C_WindowInvalidateHandlerFunc

Wrap a WindowInvalidateHandlerFunc into a C_WindowInvalidateHandlerFunc.