{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

'GI.Gdk.Objects.Display.Display' objects purpose are two fold:

* To manage and provide information about input devices (pointers and keyboards)
* To manage and provide information about the available @/GdkScreens/@


GdkDisplay objects are the GDK representation of an X Display,
which can be described as a workstation consisting of
a keyboard, a pointing device (such as a mouse) and one or more
screens.
It is used to open and keep track of various GdkScreen objects
currently instantiated by the application. It is also used to
access the keyboard(s) and mouse pointer(s) of the display.

Most of the input device handling has been factored out into
the separate 'GI.Gdk.Objects.DeviceManager.DeviceManager' object. Every display has a
device manager, which you can obtain using
'GI.Gdk.Objects.Display.displayGetDeviceManager'.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Gdk.Objects.Display
    (

-- * Exported types
    Display(..)                             ,
    IsDisplay                               ,
    toDisplay                               ,
    noDisplay                               ,


 -- * Methods
-- ** beep #method:beep#

#if ENABLE_OVERLOADING
    DisplayBeepMethodInfo                   ,
#endif
    displayBeep                             ,


-- ** close #method:close#

#if ENABLE_OVERLOADING
    DisplayCloseMethodInfo                  ,
#endif
    displayClose                            ,


-- ** deviceIsGrabbed #method:deviceIsGrabbed#

#if ENABLE_OVERLOADING
    DisplayDeviceIsGrabbedMethodInfo        ,
#endif
    displayDeviceIsGrabbed                  ,


-- ** flush #method:flush#

#if ENABLE_OVERLOADING
    DisplayFlushMethodInfo                  ,
#endif
    displayFlush                            ,


-- ** getAppLaunchContext #method:getAppLaunchContext#

#if ENABLE_OVERLOADING
    DisplayGetAppLaunchContextMethodInfo    ,
#endif
    displayGetAppLaunchContext              ,


-- ** getDefault #method:getDefault#

    displayGetDefault                       ,


-- ** getDefaultCursorSize #method:getDefaultCursorSize#

#if ENABLE_OVERLOADING
    DisplayGetDefaultCursorSizeMethodInfo   ,
#endif
    displayGetDefaultCursorSize             ,


-- ** getDefaultGroup #method:getDefaultGroup#

#if ENABLE_OVERLOADING
    DisplayGetDefaultGroupMethodInfo        ,
#endif
    displayGetDefaultGroup                  ,


-- ** getDefaultScreen #method:getDefaultScreen#

#if ENABLE_OVERLOADING
    DisplayGetDefaultScreenMethodInfo       ,
#endif
    displayGetDefaultScreen                 ,


-- ** getDefaultSeat #method:getDefaultSeat#

#if ENABLE_OVERLOADING
    DisplayGetDefaultSeatMethodInfo         ,
#endif
    displayGetDefaultSeat                   ,


-- ** getDeviceManager #method:getDeviceManager#

#if ENABLE_OVERLOADING
    DisplayGetDeviceManagerMethodInfo       ,
#endif
    displayGetDeviceManager                 ,


-- ** getEvent #method:getEvent#

#if ENABLE_OVERLOADING
    DisplayGetEventMethodInfo               ,
#endif
    displayGetEvent                         ,


-- ** getMaximalCursorSize #method:getMaximalCursorSize#

#if ENABLE_OVERLOADING
    DisplayGetMaximalCursorSizeMethodInfo   ,
#endif
    displayGetMaximalCursorSize             ,


-- ** getMonitor #method:getMonitor#

#if ENABLE_OVERLOADING
    DisplayGetMonitorMethodInfo             ,
#endif
    displayGetMonitor                       ,


-- ** getMonitorAtPoint #method:getMonitorAtPoint#

#if ENABLE_OVERLOADING
    DisplayGetMonitorAtPointMethodInfo      ,
#endif
    displayGetMonitorAtPoint                ,


-- ** getMonitorAtWindow #method:getMonitorAtWindow#

#if ENABLE_OVERLOADING
    DisplayGetMonitorAtWindowMethodInfo     ,
#endif
    displayGetMonitorAtWindow               ,


-- ** getNMonitors #method:getNMonitors#

#if ENABLE_OVERLOADING
    DisplayGetNMonitorsMethodInfo           ,
#endif
    displayGetNMonitors                     ,


-- ** getNScreens #method:getNScreens#

#if ENABLE_OVERLOADING
    DisplayGetNScreensMethodInfo            ,
#endif
    displayGetNScreens                      ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    DisplayGetNameMethodInfo                ,
#endif
    displayGetName                          ,


-- ** getPointer #method:getPointer#

#if ENABLE_OVERLOADING
    DisplayGetPointerMethodInfo             ,
#endif
    displayGetPointer                       ,


-- ** getPrimaryMonitor #method:getPrimaryMonitor#

#if ENABLE_OVERLOADING
    DisplayGetPrimaryMonitorMethodInfo      ,
#endif
    displayGetPrimaryMonitor                ,


-- ** getScreen #method:getScreen#

#if ENABLE_OVERLOADING
    DisplayGetScreenMethodInfo              ,
#endif
    displayGetScreen                        ,


-- ** getWindowAtPointer #method:getWindowAtPointer#

#if ENABLE_OVERLOADING
    DisplayGetWindowAtPointerMethodInfo     ,
#endif
    displayGetWindowAtPointer               ,


-- ** hasPending #method:hasPending#

#if ENABLE_OVERLOADING
    DisplayHasPendingMethodInfo             ,
#endif
    displayHasPending                       ,


-- ** isClosed #method:isClosed#

#if ENABLE_OVERLOADING
    DisplayIsClosedMethodInfo               ,
#endif
    displayIsClosed                         ,


-- ** keyboardUngrab #method:keyboardUngrab#

#if ENABLE_OVERLOADING
    DisplayKeyboardUngrabMethodInfo         ,
#endif
    displayKeyboardUngrab                   ,


-- ** listDevices #method:listDevices#

#if ENABLE_OVERLOADING
    DisplayListDevicesMethodInfo            ,
#endif
    displayListDevices                      ,


-- ** listSeats #method:listSeats#

#if ENABLE_OVERLOADING
    DisplayListSeatsMethodInfo              ,
#endif
    displayListSeats                        ,


-- ** notifyStartupComplete #method:notifyStartupComplete#

#if ENABLE_OVERLOADING
    DisplayNotifyStartupCompleteMethodInfo  ,
#endif
    displayNotifyStartupComplete            ,


-- ** open #method:open#

    displayOpen                             ,


-- ** openDefaultLibgtkOnly #method:openDefaultLibgtkOnly#

    displayOpenDefaultLibgtkOnly            ,


-- ** peekEvent #method:peekEvent#

#if ENABLE_OVERLOADING
    DisplayPeekEventMethodInfo              ,
#endif
    displayPeekEvent                        ,


-- ** pointerIsGrabbed #method:pointerIsGrabbed#

#if ENABLE_OVERLOADING
    DisplayPointerIsGrabbedMethodInfo       ,
#endif
    displayPointerIsGrabbed                 ,


-- ** pointerUngrab #method:pointerUngrab#

#if ENABLE_OVERLOADING
    DisplayPointerUngrabMethodInfo          ,
#endif
    displayPointerUngrab                    ,


-- ** putEvent #method:putEvent#

#if ENABLE_OVERLOADING
    DisplayPutEventMethodInfo               ,
#endif
    displayPutEvent                         ,


-- ** requestSelectionNotification #method:requestSelectionNotification#

#if ENABLE_OVERLOADING
    DisplayRequestSelectionNotificationMethodInfo,
#endif
    displayRequestSelectionNotification     ,


-- ** setDoubleClickDistance #method:setDoubleClickDistance#

#if ENABLE_OVERLOADING
    DisplaySetDoubleClickDistanceMethodInfo ,
#endif
    displaySetDoubleClickDistance           ,


-- ** setDoubleClickTime #method:setDoubleClickTime#

#if ENABLE_OVERLOADING
    DisplaySetDoubleClickTimeMethodInfo     ,
#endif
    displaySetDoubleClickTime               ,


-- ** storeClipboard #method:storeClipboard#

#if ENABLE_OVERLOADING
    DisplayStoreClipboardMethodInfo         ,
#endif
    displayStoreClipboard                   ,


-- ** supportsClipboardPersistence #method:supportsClipboardPersistence#

#if ENABLE_OVERLOADING
    DisplaySupportsClipboardPersistenceMethodInfo,
#endif
    displaySupportsClipboardPersistence     ,


-- ** supportsComposite #method:supportsComposite#

#if ENABLE_OVERLOADING
    DisplaySupportsCompositeMethodInfo      ,
#endif
    displaySupportsComposite                ,


-- ** supportsCursorAlpha #method:supportsCursorAlpha#

#if ENABLE_OVERLOADING
    DisplaySupportsCursorAlphaMethodInfo    ,
#endif
    displaySupportsCursorAlpha              ,


-- ** supportsCursorColor #method:supportsCursorColor#

#if ENABLE_OVERLOADING
    DisplaySupportsCursorColorMethodInfo    ,
#endif
    displaySupportsCursorColor              ,


-- ** supportsInputShapes #method:supportsInputShapes#

#if ENABLE_OVERLOADING
    DisplaySupportsInputShapesMethodInfo    ,
#endif
    displaySupportsInputShapes              ,


-- ** supportsSelectionNotification #method:supportsSelectionNotification#

#if ENABLE_OVERLOADING
    DisplaySupportsSelectionNotificationMethodInfo,
#endif
    displaySupportsSelectionNotification    ,


-- ** supportsShapes #method:supportsShapes#

#if ENABLE_OVERLOADING
    DisplaySupportsShapesMethodInfo         ,
#endif
    displaySupportsShapes                   ,


-- ** sync #method:sync#

#if ENABLE_OVERLOADING
    DisplaySyncMethodInfo                   ,
#endif
    displaySync                             ,


-- ** warpPointer #method:warpPointer#

#if ENABLE_OVERLOADING
    DisplayWarpPointerMethodInfo            ,
#endif
    displayWarpPointer                      ,




 -- * Signals
-- ** closed #signal:closed#

    C_DisplayClosedCallback                 ,
    DisplayClosedCallback                   ,
#if ENABLE_OVERLOADING
    DisplayClosedSignalInfo                 ,
#endif
    afterDisplayClosed                      ,
    genClosure_DisplayClosed                ,
    mk_DisplayClosedCallback                ,
    noDisplayClosedCallback                 ,
    onDisplayClosed                         ,
    wrap_DisplayClosedCallback              ,


-- ** monitorAdded #signal:monitorAdded#

    C_DisplayMonitorAddedCallback           ,
    DisplayMonitorAddedCallback             ,
#if ENABLE_OVERLOADING
    DisplayMonitorAddedSignalInfo           ,
#endif
    afterDisplayMonitorAdded                ,
    genClosure_DisplayMonitorAdded          ,
    mk_DisplayMonitorAddedCallback          ,
    noDisplayMonitorAddedCallback           ,
    onDisplayMonitorAdded                   ,
    wrap_DisplayMonitorAddedCallback        ,


-- ** monitorRemoved #signal:monitorRemoved#

    C_DisplayMonitorRemovedCallback         ,
    DisplayMonitorRemovedCallback           ,
#if ENABLE_OVERLOADING
    DisplayMonitorRemovedSignalInfo         ,
#endif
    afterDisplayMonitorRemoved              ,
    genClosure_DisplayMonitorRemoved        ,
    mk_DisplayMonitorRemovedCallback        ,
    noDisplayMonitorRemovedCallback         ,
    onDisplayMonitorRemoved                 ,
    wrap_DisplayMonitorRemovedCallback      ,


-- ** opened #signal:opened#

    C_DisplayOpenedCallback                 ,
    DisplayOpenedCallback                   ,
#if ENABLE_OVERLOADING
    DisplayOpenedSignalInfo                 ,
#endif
    afterDisplayOpened                      ,
    genClosure_DisplayOpened                ,
    mk_DisplayOpenedCallback                ,
    noDisplayOpenedCallback                 ,
    onDisplayOpened                         ,
    wrap_DisplayOpenedCallback              ,


-- ** seatAdded #signal:seatAdded#

    C_DisplaySeatAddedCallback              ,
    DisplaySeatAddedCallback                ,
#if ENABLE_OVERLOADING
    DisplaySeatAddedSignalInfo              ,
#endif
    afterDisplaySeatAdded                   ,
    genClosure_DisplaySeatAdded             ,
    mk_DisplaySeatAddedCallback             ,
    noDisplaySeatAddedCallback              ,
    onDisplaySeatAdded                      ,
    wrap_DisplaySeatAddedCallback           ,


-- ** seatRemoved #signal:seatRemoved#

    C_DisplaySeatRemovedCallback            ,
    DisplaySeatRemovedCallback              ,
#if ENABLE_OVERLOADING
    DisplaySeatRemovedSignalInfo            ,
#endif
    afterDisplaySeatRemoved                 ,
    genClosure_DisplaySeatRemoved           ,
    mk_DisplaySeatRemovedCallback           ,
    noDisplaySeatRemovedCallback            ,
    onDisplaySeatRemoved                    ,
    wrap_DisplaySeatRemovedCallback         ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gdk.Objects.AppLaunchContext as Gdk.AppLaunchContext
import {-# SOURCE #-} qualified GI.Gdk.Objects.Device as Gdk.Device
import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceManager as Gdk.DeviceManager
import {-# SOURCE #-} qualified GI.Gdk.Objects.Monitor as Gdk.Monitor
import {-# SOURCE #-} qualified GI.Gdk.Objects.Screen as Gdk.Screen
import {-# SOURCE #-} qualified GI.Gdk.Objects.Seat as Gdk.Seat
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
import {-# SOURCE #-} qualified GI.Gdk.Structs.Atom as Gdk.Atom
import {-# SOURCE #-} qualified GI.Gdk.Unions.Event as Gdk.Event

-- | Memory-managed wrapper type.
newtype Display = Display (ManagedPtr Display)
foreign import ccall "gdk_display_get_type"
    c_gdk_display_get_type :: IO GType

instance GObject Display where
    gobjectType _ = c_gdk_display_get_type


-- | Type class for types which can be safely cast to `Display`, for instance with `toDisplay`.
class GObject o => IsDisplay o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Display a) =>
    IsDisplay a
#endif
instance IsDisplay Display
instance GObject.Object.IsObject Display

-- | Cast to `Display`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDisplay :: (MonadIO m, IsDisplay o) => o -> m Display
toDisplay = liftIO . unsafeCastTo Display

-- | A convenience alias for `Nothing` :: `Maybe` `Display`.
noDisplay :: Maybe Display
noDisplay = Nothing

#if ENABLE_OVERLOADING
type family ResolveDisplayMethod (t :: Symbol) (o :: *) :: * where
    ResolveDisplayMethod "beep" o = DisplayBeepMethodInfo
    ResolveDisplayMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDisplayMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDisplayMethod "close" o = DisplayCloseMethodInfo
    ResolveDisplayMethod "deviceIsGrabbed" o = DisplayDeviceIsGrabbedMethodInfo
    ResolveDisplayMethod "flush" o = DisplayFlushMethodInfo
    ResolveDisplayMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDisplayMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDisplayMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDisplayMethod "hasPending" o = DisplayHasPendingMethodInfo
    ResolveDisplayMethod "isClosed" o = DisplayIsClosedMethodInfo
    ResolveDisplayMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDisplayMethod "keyboardUngrab" o = DisplayKeyboardUngrabMethodInfo
    ResolveDisplayMethod "listDevices" o = DisplayListDevicesMethodInfo
    ResolveDisplayMethod "listSeats" o = DisplayListSeatsMethodInfo
    ResolveDisplayMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDisplayMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDisplayMethod "notifyStartupComplete" o = DisplayNotifyStartupCompleteMethodInfo
    ResolveDisplayMethod "peekEvent" o = DisplayPeekEventMethodInfo
    ResolveDisplayMethod "pointerIsGrabbed" o = DisplayPointerIsGrabbedMethodInfo
    ResolveDisplayMethod "pointerUngrab" o = DisplayPointerUngrabMethodInfo
    ResolveDisplayMethod "putEvent" o = DisplayPutEventMethodInfo
    ResolveDisplayMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDisplayMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDisplayMethod "requestSelectionNotification" o = DisplayRequestSelectionNotificationMethodInfo
    ResolveDisplayMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDisplayMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDisplayMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDisplayMethod "storeClipboard" o = DisplayStoreClipboardMethodInfo
    ResolveDisplayMethod "supportsClipboardPersistence" o = DisplaySupportsClipboardPersistenceMethodInfo
    ResolveDisplayMethod "supportsComposite" o = DisplaySupportsCompositeMethodInfo
    ResolveDisplayMethod "supportsCursorAlpha" o = DisplaySupportsCursorAlphaMethodInfo
    ResolveDisplayMethod "supportsCursorColor" o = DisplaySupportsCursorColorMethodInfo
    ResolveDisplayMethod "supportsInputShapes" o = DisplaySupportsInputShapesMethodInfo
    ResolveDisplayMethod "supportsSelectionNotification" o = DisplaySupportsSelectionNotificationMethodInfo
    ResolveDisplayMethod "supportsShapes" o = DisplaySupportsShapesMethodInfo
    ResolveDisplayMethod "sync" o = DisplaySyncMethodInfo
    ResolveDisplayMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDisplayMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDisplayMethod "warpPointer" o = DisplayWarpPointerMethodInfo
    ResolveDisplayMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDisplayMethod "getAppLaunchContext" o = DisplayGetAppLaunchContextMethodInfo
    ResolveDisplayMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDisplayMethod "getDefaultCursorSize" o = DisplayGetDefaultCursorSizeMethodInfo
    ResolveDisplayMethod "getDefaultGroup" o = DisplayGetDefaultGroupMethodInfo
    ResolveDisplayMethod "getDefaultScreen" o = DisplayGetDefaultScreenMethodInfo
    ResolveDisplayMethod "getDefaultSeat" o = DisplayGetDefaultSeatMethodInfo
    ResolveDisplayMethod "getDeviceManager" o = DisplayGetDeviceManagerMethodInfo
    ResolveDisplayMethod "getEvent" o = DisplayGetEventMethodInfo
    ResolveDisplayMethod "getMaximalCursorSize" o = DisplayGetMaximalCursorSizeMethodInfo
    ResolveDisplayMethod "getMonitor" o = DisplayGetMonitorMethodInfo
    ResolveDisplayMethod "getMonitorAtPoint" o = DisplayGetMonitorAtPointMethodInfo
    ResolveDisplayMethod "getMonitorAtWindow" o = DisplayGetMonitorAtWindowMethodInfo
    ResolveDisplayMethod "getNMonitors" o = DisplayGetNMonitorsMethodInfo
    ResolveDisplayMethod "getNScreens" o = DisplayGetNScreensMethodInfo
    ResolveDisplayMethod "getName" o = DisplayGetNameMethodInfo
    ResolveDisplayMethod "getPointer" o = DisplayGetPointerMethodInfo
    ResolveDisplayMethod "getPrimaryMonitor" o = DisplayGetPrimaryMonitorMethodInfo
    ResolveDisplayMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDisplayMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDisplayMethod "getScreen" o = DisplayGetScreenMethodInfo
    ResolveDisplayMethod "getWindowAtPointer" o = DisplayGetWindowAtPointerMethodInfo
    ResolveDisplayMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDisplayMethod "setDoubleClickDistance" o = DisplaySetDoubleClickDistanceMethodInfo
    ResolveDisplayMethod "setDoubleClickTime" o = DisplaySetDoubleClickTimeMethodInfo
    ResolveDisplayMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDisplayMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDisplayMethod t Display, O.MethodInfo info Display p) => O.IsLabelProxy t (Display -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDisplayMethod t Display, O.MethodInfo info Display p) => O.IsLabel t (Display -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal Display::closed
{- |
The ::closed signal is emitted when the connection to the windowing
system for /@display@/ is closed.

/Since: 2.2/
-}
type DisplayClosedCallback =
    Bool
    {- ^ /@isError@/: 'True' if the display was closed due to an error -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DisplayClosedCallback`@.
noDisplayClosedCallback :: Maybe DisplayClosedCallback
noDisplayClosedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DisplayClosedCallback =
    Ptr () ->                               -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DisplayClosedCallback`.
foreign import ccall "wrapper"
    mk_DisplayClosedCallback :: C_DisplayClosedCallback -> IO (FunPtr C_DisplayClosedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_DisplayClosed :: DisplayClosedCallback -> IO Closure
genClosure_DisplayClosed cb = do
    let cb' = wrap_DisplayClosedCallback cb
    mk_DisplayClosedCallback cb' >>= newCClosure


-- | Wrap a `DisplayClosedCallback` into a `C_DisplayClosedCallback`.
wrap_DisplayClosedCallback ::
    DisplayClosedCallback ->
    C_DisplayClosedCallback
wrap_DisplayClosedCallback _cb _ isError _ = do
    let isError' = (/= 0) isError
    _cb  isError'


{- |
Connect a signal handler for the “@closed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' display #closed callback
@
-}
onDisplayClosed :: (IsDisplay a, MonadIO m) => a -> DisplayClosedCallback -> m SignalHandlerId
onDisplayClosed obj cb = liftIO $ do
    let cb' = wrap_DisplayClosedCallback cb
    cb'' <- mk_DisplayClosedCallback cb'
    connectSignalFunPtr obj "closed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@closed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' display #closed callback
@
-}
afterDisplayClosed :: (IsDisplay a, MonadIO m) => a -> DisplayClosedCallback -> m SignalHandlerId
afterDisplayClosed obj cb = liftIO $ do
    let cb' = wrap_DisplayClosedCallback cb
    cb'' <- mk_DisplayClosedCallback cb'
    connectSignalFunPtr obj "closed" cb'' SignalConnectAfter


-- signal Display::monitor-added
{- |
The ::monitor-added signal is emitted whenever a monitor is
added.

/Since: 3.22/
-}
type DisplayMonitorAddedCallback =
    Gdk.Monitor.Monitor
    {- ^ /@monitor@/: the monitor that was just added -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DisplayMonitorAddedCallback`@.
noDisplayMonitorAddedCallback :: Maybe DisplayMonitorAddedCallback
noDisplayMonitorAddedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DisplayMonitorAddedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Monitor.Monitor ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DisplayMonitorAddedCallback`.
foreign import ccall "wrapper"
    mk_DisplayMonitorAddedCallback :: C_DisplayMonitorAddedCallback -> IO (FunPtr C_DisplayMonitorAddedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_DisplayMonitorAdded :: DisplayMonitorAddedCallback -> IO Closure
genClosure_DisplayMonitorAdded cb = do
    let cb' = wrap_DisplayMonitorAddedCallback cb
    mk_DisplayMonitorAddedCallback cb' >>= newCClosure


-- | Wrap a `DisplayMonitorAddedCallback` into a `C_DisplayMonitorAddedCallback`.
wrap_DisplayMonitorAddedCallback ::
    DisplayMonitorAddedCallback ->
    C_DisplayMonitorAddedCallback
wrap_DisplayMonitorAddedCallback _cb _ monitor _ = do
    monitor' <- (newObject Gdk.Monitor.Monitor) monitor
    _cb  monitor'


{- |
Connect a signal handler for the “@monitor-added@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' display #monitorAdded callback
@
-}
onDisplayMonitorAdded :: (IsDisplay a, MonadIO m) => a -> DisplayMonitorAddedCallback -> m SignalHandlerId
onDisplayMonitorAdded obj cb = liftIO $ do
    let cb' = wrap_DisplayMonitorAddedCallback cb
    cb'' <- mk_DisplayMonitorAddedCallback cb'
    connectSignalFunPtr obj "monitor-added" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@monitor-added@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' display #monitorAdded callback
@
-}
afterDisplayMonitorAdded :: (IsDisplay a, MonadIO m) => a -> DisplayMonitorAddedCallback -> m SignalHandlerId
afterDisplayMonitorAdded obj cb = liftIO $ do
    let cb' = wrap_DisplayMonitorAddedCallback cb
    cb'' <- mk_DisplayMonitorAddedCallback cb'
    connectSignalFunPtr obj "monitor-added" cb'' SignalConnectAfter


-- signal Display::monitor-removed
{- |
The ::monitor-removed signal is emitted whenever a monitor is
removed.

/Since: 3.22/
-}
type DisplayMonitorRemovedCallback =
    Gdk.Monitor.Monitor
    {- ^ /@monitor@/: the monitor that was just removed -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DisplayMonitorRemovedCallback`@.
noDisplayMonitorRemovedCallback :: Maybe DisplayMonitorRemovedCallback
noDisplayMonitorRemovedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DisplayMonitorRemovedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Monitor.Monitor ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DisplayMonitorRemovedCallback`.
foreign import ccall "wrapper"
    mk_DisplayMonitorRemovedCallback :: C_DisplayMonitorRemovedCallback -> IO (FunPtr C_DisplayMonitorRemovedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_DisplayMonitorRemoved :: DisplayMonitorRemovedCallback -> IO Closure
genClosure_DisplayMonitorRemoved cb = do
    let cb' = wrap_DisplayMonitorRemovedCallback cb
    mk_DisplayMonitorRemovedCallback cb' >>= newCClosure


-- | Wrap a `DisplayMonitorRemovedCallback` into a `C_DisplayMonitorRemovedCallback`.
wrap_DisplayMonitorRemovedCallback ::
    DisplayMonitorRemovedCallback ->
    C_DisplayMonitorRemovedCallback
wrap_DisplayMonitorRemovedCallback _cb _ monitor _ = do
    monitor' <- (newObject Gdk.Monitor.Monitor) monitor
    _cb  monitor'


{- |
Connect a signal handler for the “@monitor-removed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' display #monitorRemoved callback
@
-}
onDisplayMonitorRemoved :: (IsDisplay a, MonadIO m) => a -> DisplayMonitorRemovedCallback -> m SignalHandlerId
onDisplayMonitorRemoved obj cb = liftIO $ do
    let cb' = wrap_DisplayMonitorRemovedCallback cb
    cb'' <- mk_DisplayMonitorRemovedCallback cb'
    connectSignalFunPtr obj "monitor-removed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@monitor-removed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' display #monitorRemoved callback
@
-}
afterDisplayMonitorRemoved :: (IsDisplay a, MonadIO m) => a -> DisplayMonitorRemovedCallback -> m SignalHandlerId
afterDisplayMonitorRemoved obj cb = liftIO $ do
    let cb' = wrap_DisplayMonitorRemovedCallback cb
    cb'' <- mk_DisplayMonitorRemovedCallback cb'
    connectSignalFunPtr obj "monitor-removed" cb'' SignalConnectAfter


-- signal Display::opened
{- |
The ::opened signal is emitted when the connection to the windowing
system for /@display@/ is opened.
-}
type DisplayOpenedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DisplayOpenedCallback`@.
noDisplayOpenedCallback :: Maybe DisplayOpenedCallback
noDisplayOpenedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DisplayOpenedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DisplayOpenedCallback`.
foreign import ccall "wrapper"
    mk_DisplayOpenedCallback :: C_DisplayOpenedCallback -> IO (FunPtr C_DisplayOpenedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_DisplayOpened :: DisplayOpenedCallback -> IO Closure
genClosure_DisplayOpened cb = do
    let cb' = wrap_DisplayOpenedCallback cb
    mk_DisplayOpenedCallback cb' >>= newCClosure


-- | Wrap a `DisplayOpenedCallback` into a `C_DisplayOpenedCallback`.
wrap_DisplayOpenedCallback ::
    DisplayOpenedCallback ->
    C_DisplayOpenedCallback
wrap_DisplayOpenedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@opened@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' display #opened callback
@
-}
onDisplayOpened :: (IsDisplay a, MonadIO m) => a -> DisplayOpenedCallback -> m SignalHandlerId
onDisplayOpened obj cb = liftIO $ do
    let cb' = wrap_DisplayOpenedCallback cb
    cb'' <- mk_DisplayOpenedCallback cb'
    connectSignalFunPtr obj "opened" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@opened@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' display #opened callback
@
-}
afterDisplayOpened :: (IsDisplay a, MonadIO m) => a -> DisplayOpenedCallback -> m SignalHandlerId
afterDisplayOpened obj cb = liftIO $ do
    let cb' = wrap_DisplayOpenedCallback cb
    cb'' <- mk_DisplayOpenedCallback cb'
    connectSignalFunPtr obj "opened" cb'' SignalConnectAfter


-- signal Display::seat-added
{- |
The ::seat-added signal is emitted whenever a new seat is made
known to the windowing system.

/Since: 3.20/
-}
type DisplaySeatAddedCallback =
    Gdk.Seat.Seat
    {- ^ /@seat@/: the seat that was just added -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DisplaySeatAddedCallback`@.
noDisplaySeatAddedCallback :: Maybe DisplaySeatAddedCallback
noDisplaySeatAddedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DisplaySeatAddedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Seat.Seat ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DisplaySeatAddedCallback`.
foreign import ccall "wrapper"
    mk_DisplaySeatAddedCallback :: C_DisplaySeatAddedCallback -> IO (FunPtr C_DisplaySeatAddedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_DisplaySeatAdded :: DisplaySeatAddedCallback -> IO Closure
genClosure_DisplaySeatAdded cb = do
    let cb' = wrap_DisplaySeatAddedCallback cb
    mk_DisplaySeatAddedCallback cb' >>= newCClosure


-- | Wrap a `DisplaySeatAddedCallback` into a `C_DisplaySeatAddedCallback`.
wrap_DisplaySeatAddedCallback ::
    DisplaySeatAddedCallback ->
    C_DisplaySeatAddedCallback
wrap_DisplaySeatAddedCallback _cb _ seat _ = do
    seat' <- (newObject Gdk.Seat.Seat) seat
    _cb  seat'


{- |
Connect a signal handler for the “@seat-added@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' display #seatAdded callback
@
-}
onDisplaySeatAdded :: (IsDisplay a, MonadIO m) => a -> DisplaySeatAddedCallback -> m SignalHandlerId
onDisplaySeatAdded obj cb = liftIO $ do
    let cb' = wrap_DisplaySeatAddedCallback cb
    cb'' <- mk_DisplaySeatAddedCallback cb'
    connectSignalFunPtr obj "seat-added" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@seat-added@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' display #seatAdded callback
@
-}
afterDisplaySeatAdded :: (IsDisplay a, MonadIO m) => a -> DisplaySeatAddedCallback -> m SignalHandlerId
afterDisplaySeatAdded obj cb = liftIO $ do
    let cb' = wrap_DisplaySeatAddedCallback cb
    cb'' <- mk_DisplaySeatAddedCallback cb'
    connectSignalFunPtr obj "seat-added" cb'' SignalConnectAfter


-- signal Display::seat-removed
{- |
The ::seat-removed signal is emitted whenever a seat is removed
by the windowing system.

/Since: 3.20/
-}
type DisplaySeatRemovedCallback =
    Gdk.Seat.Seat
    {- ^ /@seat@/: the seat that was just removed -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DisplaySeatRemovedCallback`@.
noDisplaySeatRemovedCallback :: Maybe DisplaySeatRemovedCallback
noDisplaySeatRemovedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DisplaySeatRemovedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Seat.Seat ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DisplaySeatRemovedCallback`.
foreign import ccall "wrapper"
    mk_DisplaySeatRemovedCallback :: C_DisplaySeatRemovedCallback -> IO (FunPtr C_DisplaySeatRemovedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_DisplaySeatRemoved :: DisplaySeatRemovedCallback -> IO Closure
genClosure_DisplaySeatRemoved cb = do
    let cb' = wrap_DisplaySeatRemovedCallback cb
    mk_DisplaySeatRemovedCallback cb' >>= newCClosure


-- | Wrap a `DisplaySeatRemovedCallback` into a `C_DisplaySeatRemovedCallback`.
wrap_DisplaySeatRemovedCallback ::
    DisplaySeatRemovedCallback ->
    C_DisplaySeatRemovedCallback
wrap_DisplaySeatRemovedCallback _cb _ seat _ = do
    seat' <- (newObject Gdk.Seat.Seat) seat
    _cb  seat'


{- |
Connect a signal handler for the “@seat-removed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' display #seatRemoved callback
@
-}
onDisplaySeatRemoved :: (IsDisplay a, MonadIO m) => a -> DisplaySeatRemovedCallback -> m SignalHandlerId
onDisplaySeatRemoved obj cb = liftIO $ do
    let cb' = wrap_DisplaySeatRemovedCallback cb
    cb'' <- mk_DisplaySeatRemovedCallback cb'
    connectSignalFunPtr obj "seat-removed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@seat-removed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' display #seatRemoved callback
@
-}
afterDisplaySeatRemoved :: (IsDisplay a, MonadIO m) => a -> DisplaySeatRemovedCallback -> m SignalHandlerId
afterDisplaySeatRemoved obj cb = liftIO $ do
    let cb' = wrap_DisplaySeatRemovedCallback cb
    cb'' <- mk_DisplaySeatRemovedCallback cb'
    connectSignalFunPtr obj "seat-removed" cb'' SignalConnectAfter


#if ENABLE_OVERLOADING
instance O.HasAttributeList Display
type instance O.AttributeList Display = DisplayAttributeList
type DisplayAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
data DisplayClosedSignalInfo
instance SignalInfo DisplayClosedSignalInfo where
    type HaskellCallbackType DisplayClosedSignalInfo = DisplayClosedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DisplayClosedCallback cb
        cb'' <- mk_DisplayClosedCallback cb'
        connectSignalFunPtr obj "closed" cb'' connectMode

data DisplayMonitorAddedSignalInfo
instance SignalInfo DisplayMonitorAddedSignalInfo where
    type HaskellCallbackType DisplayMonitorAddedSignalInfo = DisplayMonitorAddedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DisplayMonitorAddedCallback cb
        cb'' <- mk_DisplayMonitorAddedCallback cb'
        connectSignalFunPtr obj "monitor-added" cb'' connectMode

data DisplayMonitorRemovedSignalInfo
instance SignalInfo DisplayMonitorRemovedSignalInfo where
    type HaskellCallbackType DisplayMonitorRemovedSignalInfo = DisplayMonitorRemovedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DisplayMonitorRemovedCallback cb
        cb'' <- mk_DisplayMonitorRemovedCallback cb'
        connectSignalFunPtr obj "monitor-removed" cb'' connectMode

data DisplayOpenedSignalInfo
instance SignalInfo DisplayOpenedSignalInfo where
    type HaskellCallbackType DisplayOpenedSignalInfo = DisplayOpenedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DisplayOpenedCallback cb
        cb'' <- mk_DisplayOpenedCallback cb'
        connectSignalFunPtr obj "opened" cb'' connectMode

data DisplaySeatAddedSignalInfo
instance SignalInfo DisplaySeatAddedSignalInfo where
    type HaskellCallbackType DisplaySeatAddedSignalInfo = DisplaySeatAddedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DisplaySeatAddedCallback cb
        cb'' <- mk_DisplaySeatAddedCallback cb'
        connectSignalFunPtr obj "seat-added" cb'' connectMode

data DisplaySeatRemovedSignalInfo
instance SignalInfo DisplaySeatRemovedSignalInfo where
    type HaskellCallbackType DisplaySeatRemovedSignalInfo = DisplaySeatRemovedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DisplaySeatRemovedCallback cb
        cb'' <- mk_DisplaySeatRemovedCallback cb'
        connectSignalFunPtr obj "seat-removed" cb'' connectMode

type instance O.SignalList Display = DisplaySignalList
type DisplaySignalList = ('[ '("closed", DisplayClosedSignalInfo), '("monitorAdded", DisplayMonitorAddedSignalInfo), '("monitorRemoved", DisplayMonitorRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("opened", DisplayOpenedSignalInfo), '("seatAdded", DisplaySeatAddedSignalInfo), '("seatRemoved", DisplaySeatRemovedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Display::beep
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_beep" gdk_display_beep ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO ()

{- |
Emits a short beep on /@display@/

/Since: 2.2/
-}
displayBeep ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m ()
displayBeep display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_beep display'
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplayBeepMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplayBeepMethodInfo a signature where
    overloadedMethod _ = displayBeep

#endif

-- method Display::close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_close" gdk_display_close ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO ()

{- |
Closes the connection to the windowing system for the given display,
and cleans up associated resources.

/Since: 2.2/
-}
displayClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m ()
displayClose display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_close display'
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplayCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplayCloseMethodInfo a signature where
    overloadedMethod _ = displayClose

#endif

-- method Display::device_is_grabbed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_device_is_grabbed" gdk_display_device_is_grabbed ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Gdk.Device.Device ->                -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CInt

{- |
Returns 'True' if there is an ongoing grab on /@device@/ for /@display@/.
-}
displayDeviceIsGrabbed ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a, Gdk.Device.IsDevice b) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> b
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if there is a grab in effect for /@device@/. -}
displayDeviceIsGrabbed display device = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_display_device_is_grabbed display' device'
    let result' = (/= 0) result
    touchManagedPtr display
    touchManagedPtr device
    return result'

#if ENABLE_OVERLOADING
data DisplayDeviceIsGrabbedMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsDisplay a, Gdk.Device.IsDevice b) => O.MethodInfo DisplayDeviceIsGrabbedMethodInfo a signature where
    overloadedMethod _ = displayDeviceIsGrabbed

#endif

-- method Display::flush
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_flush" gdk_display_flush ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO ()

{- |
Flushes any requests queued for the windowing system; this happens automatically
when the main loop blocks waiting for new events, but if your application
is drawing without returning control to the main loop, you may need
to call this function explicitly. A common case where this function
needs to be called is when an application is executing drawing commands
from a thread other than the thread where the main loop is running.

This is most useful for X11. On windowing systems where requests are
handled synchronously, this function will do nothing.

/Since: 2.4/
-}
displayFlush ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m ()
displayFlush display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_flush display'
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplayFlushMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplayFlushMethodInfo a signature where
    overloadedMethod _ = displayFlush

#endif

-- method Display::get_app_launch_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "AppLaunchContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_app_launch_context" gdk_display_get_app_launch_context ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.AppLaunchContext.AppLaunchContext)

{- |
Returns a 'GI.Gdk.Objects.AppLaunchContext.AppLaunchContext' suitable for launching
applications on the given display.

/Since: 3.0/
-}
displayGetAppLaunchContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Gdk.AppLaunchContext.AppLaunchContext
    {- ^ __Returns:__ a new 'GI.Gdk.Objects.AppLaunchContext.AppLaunchContext' for /@display@/.
    Free with 'GI.GObject.Objects.Object.objectUnref' when done -}
displayGetAppLaunchContext display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_app_launch_context display'
    checkUnexpectedReturnNULL "displayGetAppLaunchContext" result
    result' <- (wrapObject Gdk.AppLaunchContext.AppLaunchContext) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayGetAppLaunchContextMethodInfo
instance (signature ~ (m Gdk.AppLaunchContext.AppLaunchContext), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetAppLaunchContextMethodInfo a signature where
    overloadedMethod _ = displayGetAppLaunchContext

#endif

-- method Display::get_default_cursor_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_default_cursor_size" gdk_display_get_default_cursor_size ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO Word32

{- |
Returns the default size to use for cursors on /@display@/.

/Since: 2.4/
-}
displayGetDefaultCursorSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Word32
    {- ^ __Returns:__ the default cursor size. -}
displayGetDefaultCursorSize display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_default_cursor_size display'
    touchManagedPtr display
    return result

#if ENABLE_OVERLOADING
data DisplayGetDefaultCursorSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetDefaultCursorSizeMethodInfo a signature where
    overloadedMethod _ = displayGetDefaultCursorSize

#endif

-- method Display::get_default_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_default_group" gdk_display_get_default_group ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.Window.Window)

{- |
Returns the default group leader window for all toplevel windows
on /@display@/. This window is implicitly created by GDK.
See 'GI.Gdk.Objects.Window.windowSetGroup'.

/Since: 2.4/
-}
displayGetDefaultGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Gdk.Window.Window
    {- ^ __Returns:__ The default group leader window
for /@display@/ -}
displayGetDefaultGroup display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_default_group display'
    checkUnexpectedReturnNULL "displayGetDefaultGroup" result
    result' <- (newObject Gdk.Window.Window) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayGetDefaultGroupMethodInfo
instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetDefaultGroupMethodInfo a signature where
    overloadedMethod _ = displayGetDefaultGroup

#endif

-- method Display::get_default_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Screen"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_default_screen" gdk_display_get_default_screen ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.Screen.Screen)

{- |
Get the default 'GI.Gdk.Objects.Screen.Screen' for /@display@/.

/Since: 2.2/
-}
displayGetDefaultScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Gdk.Screen.Screen
    {- ^ __Returns:__ the default 'GI.Gdk.Objects.Screen.Screen' object for /@display@/ -}
displayGetDefaultScreen display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_default_screen display'
    checkUnexpectedReturnNULL "displayGetDefaultScreen" result
    result' <- (newObject Gdk.Screen.Screen) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayGetDefaultScreenMethodInfo
instance (signature ~ (m Gdk.Screen.Screen), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetDefaultScreenMethodInfo a signature where
    overloadedMethod _ = displayGetDefaultScreen

#endif

-- method Display::get_default_seat
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Seat"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_default_seat" gdk_display_get_default_seat ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.Seat.Seat)

{- |
Returns the default 'GI.Gdk.Objects.Seat.Seat' for this display.

/Since: 3.20/
-}
displayGetDefaultSeat ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Gdk.Seat.Seat
    {- ^ __Returns:__ the default seat. -}
displayGetDefaultSeat display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_default_seat display'
    checkUnexpectedReturnNULL "displayGetDefaultSeat" result
    result' <- (newObject Gdk.Seat.Seat) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayGetDefaultSeatMethodInfo
instance (signature ~ (m Gdk.Seat.Seat), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetDefaultSeatMethodInfo a signature where
    overloadedMethod _ = displayGetDefaultSeat

#endif

-- method Display::get_device_manager
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "DeviceManager"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_device_manager" gdk_display_get_device_manager ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.DeviceManager.DeviceManager)

{-# DEPRECATED displayGetDeviceManager ["(Since version 3.20.)","Use 'GI.Gdk.Objects.Display.displayGetDefaultSeat' and 'GI.Gdk.Objects.Seat.Seat' operations."] #-}
{- |
Returns the 'GI.Gdk.Objects.DeviceManager.DeviceManager' associated to /@display@/.

/Since: 3.0/
-}
displayGetDeviceManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display'. -}
    -> m (Maybe Gdk.DeviceManager.DeviceManager)
    {- ^ __Returns:__ A 'GI.Gdk.Objects.DeviceManager.DeviceManager', or
         'Nothing'. This memory is owned by GDK and must not be freed
         or unreferenced. -}
displayGetDeviceManager display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_device_manager display'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.DeviceManager.DeviceManager) result'
        return result''
    touchManagedPtr display
    return maybeResult

#if ENABLE_OVERLOADING
data DisplayGetDeviceManagerMethodInfo
instance (signature ~ (m (Maybe Gdk.DeviceManager.DeviceManager)), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetDeviceManagerMethodInfo a signature where
    overloadedMethod _ = displayGetDeviceManager

#endif

-- method Display::get_event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Event"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_event" gdk_display_get_event ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.Event.Event)

{- |
Gets the next 'GI.Gdk.Unions.Event.Event' to be processed for /@display@/, fetching events from the
windowing system if necessary.

/Since: 2.2/
-}
displayGetEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m (Maybe Gdk.Event.Event)
    {- ^ __Returns:__ the next 'GI.Gdk.Unions.Event.Event' to be processed, or 'Nothing'
if no events are pending. The returned 'GI.Gdk.Unions.Event.Event' should be freed
with 'GI.Gdk.Unions.Event.eventFree'. -}
displayGetEvent display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_event display'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Gdk.Event.Event) result'
        return result''
    touchManagedPtr display
    return maybeResult

#if ENABLE_OVERLOADING
data DisplayGetEventMethodInfo
instance (signature ~ (m (Maybe Gdk.Event.Event)), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetEventMethodInfo a signature where
    overloadedMethod _ = displayGetEvent

#endif

-- method Display::get_maximal_cursor_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the return location for the maximal cursor width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the return location for the maximal cursor height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_maximal_cursor_size" gdk_display_get_maximal_cursor_size ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Word32 ->                           -- width : TBasicType TUInt
    Ptr Word32 ->                           -- height : TBasicType TUInt
    IO ()

{- |
Gets the maximal size to use for cursors on /@display@/.

/Since: 2.4/
-}
displayGetMaximalCursorSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m ((Word32, Word32))
displayGetMaximalCursorSize display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    width <- allocMem :: IO (Ptr Word32)
    height <- allocMem :: IO (Ptr Word32)
    gdk_display_get_maximal_cursor_size display' width height
    width' <- peek width
    height' <- peek height
    touchManagedPtr display
    freeMem width
    freeMem height
    return (width', height')

#if ENABLE_OVERLOADING
data DisplayGetMaximalCursorSizeMethodInfo
instance (signature ~ (m ((Word32, Word32))), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetMaximalCursorSizeMethodInfo a signature where
    overloadedMethod _ = displayGetMaximalCursorSize

#endif

-- method Display::get_monitor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "monitor_num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of the monitor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Monitor"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_monitor" gdk_display_get_monitor ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Int32 ->                                -- monitor_num : TBasicType TInt
    IO (Ptr Gdk.Monitor.Monitor)

{- |
Gets a monitor associated with this display.

/Since: 3.22/
-}
displayGetMonitor ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> Int32
    {- ^ /@monitorNum@/: number of the monitor -}
    -> m (Maybe Gdk.Monitor.Monitor)
    {- ^ __Returns:__ the 'GI.Gdk.Objects.Monitor.Monitor', or 'Nothing' if
   /@monitorNum@/ is not a valid monitor number -}
displayGetMonitor display monitorNum = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_monitor display' monitorNum
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Monitor.Monitor) result'
        return result''
    touchManagedPtr display
    return maybeResult

#if ENABLE_OVERLOADING
data DisplayGetMonitorMethodInfo
instance (signature ~ (Int32 -> m (Maybe Gdk.Monitor.Monitor)), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetMonitorMethodInfo a signature where
    overloadedMethod _ = displayGetMonitor

#endif

-- method Display::get_monitor_at_point
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x coordinate of the point", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y coordinate of the point", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Monitor"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_monitor_at_point" gdk_display_get_monitor_at_point ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    IO (Ptr Gdk.Monitor.Monitor)

{- |
Gets the monitor in which the point (/@x@/, /@y@/) is located,
or a nearby monitor if the point is not in any monitor.

/Since: 3.22/
-}
displayGetMonitorAtPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> Int32
    {- ^ /@x@/: the x coordinate of the point -}
    -> Int32
    {- ^ /@y@/: the y coordinate of the point -}
    -> m Gdk.Monitor.Monitor
    {- ^ __Returns:__ the monitor containing the point -}
displayGetMonitorAtPoint display x y = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_monitor_at_point display' x y
    checkUnexpectedReturnNULL "displayGetMonitorAtPoint" result
    result' <- (newObject Gdk.Monitor.Monitor) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayGetMonitorAtPointMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Gdk.Monitor.Monitor), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetMonitorAtPointMethodInfo a signature where
    overloadedMethod _ = displayGetMonitorAtPoint

#endif

-- method Display::get_monitor_at_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Monitor"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_monitor_at_window" gdk_display_get_monitor_at_window ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
    IO (Ptr Gdk.Monitor.Monitor)

{- |
Gets the monitor in which the largest area of /@window@/
resides, or a monitor close to /@window@/ if it is outside
of all monitors.

/Since: 3.22/
-}
displayGetMonitorAtWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a, Gdk.Window.IsWindow b) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> b
    {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -}
    -> m Gdk.Monitor.Monitor
    {- ^ __Returns:__ the monitor with the largest overlap with /@window@/ -}
displayGetMonitorAtWindow display window = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    window' <- unsafeManagedPtrCastPtr window
    result <- gdk_display_get_monitor_at_window display' window'
    checkUnexpectedReturnNULL "displayGetMonitorAtWindow" result
    result' <- (newObject Gdk.Monitor.Monitor) result
    touchManagedPtr display
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data DisplayGetMonitorAtWindowMethodInfo
instance (signature ~ (b -> m Gdk.Monitor.Monitor), MonadIO m, IsDisplay a, Gdk.Window.IsWindow b) => O.MethodInfo DisplayGetMonitorAtWindowMethodInfo a signature where
    overloadedMethod _ = displayGetMonitorAtWindow

#endif

-- method Display::get_n_monitors
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_n_monitors" gdk_display_get_n_monitors ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO Int32

{- |
Gets the number of monitors that belong to /@display@/.

The returned number is valid until the next emission of the
'GI.Gdk.Objects.Display.Display'::@/monitor-added/@ or 'GI.Gdk.Objects.Display.Display'::@/monitor-removed/@ signal.

/Since: 3.22/
-}
displayGetNMonitors ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Int32
    {- ^ __Returns:__ the number of monitors -}
displayGetNMonitors display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_n_monitors display'
    touchManagedPtr display
    return result

#if ENABLE_OVERLOADING
data DisplayGetNMonitorsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetNMonitorsMethodInfo a signature where
    overloadedMethod _ = displayGetNMonitors

#endif

-- method Display::get_n_screens
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_n_screens" gdk_display_get_n_screens ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO Int32

{-# DEPRECATED displayGetNScreens ["(Since version 3.10)","The number of screens is always 1."] #-}
{- |
Gets the number of screen managed by the /@display@/.

/Since: 2.2/
-}
displayGetNScreens ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Int32
    {- ^ __Returns:__ number of screens. -}
displayGetNScreens display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_n_screens display'
    touchManagedPtr display
    return result

#if ENABLE_OVERLOADING
data DisplayGetNScreensMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetNScreensMethodInfo a signature where
    overloadedMethod _ = displayGetNScreens

#endif

-- method Display::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_name" gdk_display_get_name ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CString

{- |
Gets the name of the display.

/Since: 2.2/
-}
displayGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m T.Text
    {- ^ __Returns:__ a string representing the display name. This string is owned
by GDK and should not be modified or freed. -}
displayGetName display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_name display'
    checkUnexpectedReturnNULL "displayGetName" result
    result' <- cstringToText result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetNameMethodInfo a signature where
    overloadedMethod _ = displayGetName

#endif

-- method Display::get_pointer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the screen that the\n         cursor is on, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window X coordinate of pointer, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window Y coordinate of pointer, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "mask", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store current modifier mask, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_pointer" gdk_display_get_pointer ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr (Ptr Gdk.Screen.Screen) ->          -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
    Ptr Int32 ->                            -- x : TBasicType TInt
    Ptr Int32 ->                            -- y : TBasicType TInt
    Ptr CUInt ->                            -- mask : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO ()

{-# DEPRECATED displayGetPointer ["(Since version 3.0)","Use 'GI.Gdk.Objects.Device.deviceGetPosition' instead."] #-}
{- |
Gets the current location of the pointer and the current modifier
mask for a given display.

/Since: 2.2/
-}
displayGetPointer ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m ((Gdk.Screen.Screen, Int32, Int32, [Gdk.Flags.ModifierType]))
displayGetPointer display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    screen <- allocMem :: IO (Ptr (Ptr Gdk.Screen.Screen))
    x <- allocMem :: IO (Ptr Int32)
    y <- allocMem :: IO (Ptr Int32)
    mask <- allocMem :: IO (Ptr CUInt)
    gdk_display_get_pointer display' screen x y mask
    screen' <- peek screen
    screen'' <- (newObject Gdk.Screen.Screen) screen'
    x' <- peek x
    y' <- peek y
    mask' <- peek mask
    let mask'' = wordToGFlags mask'
    touchManagedPtr display
    freeMem screen
    freeMem x
    freeMem y
    freeMem mask
    return (screen'', x', y', mask'')

#if ENABLE_OVERLOADING
data DisplayGetPointerMethodInfo
instance (signature ~ (m ((Gdk.Screen.Screen, Int32, Int32, [Gdk.Flags.ModifierType]))), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetPointerMethodInfo a signature where
    overloadedMethod _ = displayGetPointer

#endif

-- method Display::get_primary_monitor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Monitor"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_primary_monitor" gdk_display_get_primary_monitor ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.Monitor.Monitor)

{- |
Gets the primary monitor for the display.

The primary monitor is considered the monitor where the “main desktop”
lives. While normal application windows typically allow the window
manager to place the windows, specialized desktop applications
such as panels should place themselves on the primary monitor.

/Since: 3.22/
-}
displayGetPrimaryMonitor ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m (Maybe Gdk.Monitor.Monitor)
    {- ^ __Returns:__ the primary monitor, or 'Nothing' if no primary
    monitor is configured by the user -}
displayGetPrimaryMonitor display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_primary_monitor display'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Monitor.Monitor) result'
        return result''
    touchManagedPtr display
    return maybeResult

#if ENABLE_OVERLOADING
data DisplayGetPrimaryMonitorMethodInfo
instance (signature ~ (m (Maybe Gdk.Monitor.Monitor)), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetPrimaryMonitorMethodInfo a signature where
    overloadedMethod _ = displayGetPrimaryMonitor

#endif

-- method Display::get_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen_num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the screen number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Screen"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_screen" gdk_display_get_screen ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Int32 ->                                -- screen_num : TBasicType TInt
    IO (Ptr Gdk.Screen.Screen)

{-# DEPRECATED displayGetScreen ["(Since version 3.20)","There is only one screen; use 'GI.Gdk.Objects.Display.displayGetDefaultScreen' to get it."] #-}
{- |
Returns a screen object for one of the screens of the display.

/Since: 2.2/
-}
displayGetScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> Int32
    {- ^ /@screenNum@/: the screen number -}
    -> m Gdk.Screen.Screen
    {- ^ __Returns:__ the 'GI.Gdk.Objects.Screen.Screen' object -}
displayGetScreen display screenNum = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_get_screen display' screenNum
    checkUnexpectedReturnNULL "displayGetScreen" result
    result' <- (newObject Gdk.Screen.Screen) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayGetScreenMethodInfo
instance (signature ~ (Int32 -> m Gdk.Screen.Screen), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetScreenMethodInfo a signature where
    overloadedMethod _ = displayGetScreen

#endif

-- method Display::get_window_at_pointer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "win_x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for x coordinate of the pointer location relative\n   to the window origin, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "win_y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for y coordinate of the pointer location relative\n &    to the window origin, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_window_at_pointer" gdk_display_get_window_at_pointer ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Int32 ->                            -- win_x : TBasicType TInt
    Ptr Int32 ->                            -- win_y : TBasicType TInt
    IO (Ptr Gdk.Window.Window)

{-# DEPRECATED displayGetWindowAtPointer ["(Since version 3.0)","Use 'GI.Gdk.Objects.Device.deviceGetWindowAtPosition' instead."] #-}
{- |
Obtains the window underneath the mouse pointer, returning the location
of the pointer in that window in /@winX@/, /@winY@/ for /@screen@/. Returns 'Nothing'
if the window under the mouse pointer is not known to GDK (for example,
belongs to another application).

/Since: 2.2/
-}
displayGetWindowAtPointer ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m ((Maybe Gdk.Window.Window, Int32, Int32))
    {- ^ __Returns:__ the window under the mouse
  pointer, or 'Nothing' -}
displayGetWindowAtPointer display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    winX <- allocMem :: IO (Ptr Int32)
    winY <- allocMem :: IO (Ptr Int32)
    result <- gdk_display_get_window_at_pointer display' winX winY
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Window.Window) result'
        return result''
    winX' <- peek winX
    winY' <- peek winY
    touchManagedPtr display
    freeMem winX
    freeMem winY
    return (maybeResult, winX', winY')

#if ENABLE_OVERLOADING
data DisplayGetWindowAtPointerMethodInfo
instance (signature ~ (m ((Maybe Gdk.Window.Window, Int32, Int32))), MonadIO m, IsDisplay a) => O.MethodInfo DisplayGetWindowAtPointerMethodInfo a signature where
    overloadedMethod _ = displayGetWindowAtPointer

#endif

-- method Display::has_pending
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_has_pending" gdk_display_has_pending ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Returns whether the display has events that are waiting
to be processed.

/Since: 3.0/
-}
displayHasPending ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if there are events ready to be processed. -}
displayHasPending display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_has_pending display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayHasPendingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplayHasPendingMethodInfo a signature where
    overloadedMethod _ = displayHasPending

#endif

-- method Display::is_closed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_is_closed" gdk_display_is_closed ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Finds out if the display has been closed.

/Since: 2.22/
-}
displayIsClosed ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the display is closed. -}
displayIsClosed display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_is_closed display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayIsClosedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplayIsClosedMethodInfo a signature where
    overloadedMethod _ = displayIsClosed

#endif

-- method Display::keyboard_ungrab
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timestap (e.g #GDK_CURRENT_TIME).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_keyboard_ungrab" gdk_display_keyboard_ungrab ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Word32 ->                               -- time_ : TBasicType TUInt32
    IO ()

{-# DEPRECATED displayKeyboardUngrab ["(Since version 3.0)","Use 'GI.Gdk.Objects.Device.deviceUngrab', together with 'GI.Gdk.Objects.Device.deviceGrab'","            instead."] #-}
{- |
Release any keyboard grab

/Since: 2.2/
-}
displayKeyboardUngrab ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display'. -}
    -> Word32
    {- ^ /@time_@/: a timestap (e.g 'GI.Gdk.Constants.CURRENT_TIME'). -}
    -> m ()
displayKeyboardUngrab display time_ = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_keyboard_ungrab display' time_
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplayKeyboardUngrabMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplayKeyboardUngrabMethodInfo a signature where
    overloadedMethod _ = displayKeyboardUngrab

#endif

-- method Display::list_devices
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Device"})))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_list_devices" gdk_display_list_devices ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr (GList (Ptr Gdk.Device.Device)))

{-# DEPRECATED displayListDevices ["(Since version 3.0)","Use 'GI.Gdk.Objects.DeviceManager.deviceManagerListDevices' instead."] #-}
{- |
Returns the list of available input devices attached to /@display@/.
The list is statically allocated and should not be freed.

/Since: 2.2/
-}
displayListDevices ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m [Gdk.Device.Device]
    {- ^ __Returns:__ 
    a list of 'GI.Gdk.Objects.Device.Device' -}
displayListDevices display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_list_devices display'
    result' <- unpackGList result
    result'' <- mapM (newObject Gdk.Device.Device) result'
    touchManagedPtr display
    return result''

#if ENABLE_OVERLOADING
data DisplayListDevicesMethodInfo
instance (signature ~ (m [Gdk.Device.Device]), MonadIO m, IsDisplay a) => O.MethodInfo DisplayListDevicesMethodInfo a signature where
    overloadedMethod _ = displayListDevices

#endif

-- method Display::list_seats
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Seat"})))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_list_seats" gdk_display_list_seats ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr (GList (Ptr Gdk.Seat.Seat)))

{- |
Returns the list of seats known to /@display@/.

/Since: 3.20/
-}
displayListSeats ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m [Gdk.Seat.Seat]
    {- ^ __Returns:__ the
         list of seats known to the 'GI.Gdk.Objects.Display.Display' -}
displayListSeats display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_list_seats display'
    result' <- unpackGList result
    result'' <- mapM (newObject Gdk.Seat.Seat) result'
    g_list_free result
    touchManagedPtr display
    return result''

#if ENABLE_OVERLOADING
data DisplayListSeatsMethodInfo
instance (signature ~ (m [Gdk.Seat.Seat]), MonadIO m, IsDisplay a) => O.MethodInfo DisplayListSeatsMethodInfo a signature where
    overloadedMethod _ = displayListSeats

#endif

-- method Display::notify_startup_complete
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "startup_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a startup-notification identifier, for which\n    notification process should be completed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_notify_startup_complete" gdk_display_notify_startup_complete ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    CString ->                              -- startup_id : TBasicType TUTF8
    IO ()

{- |
Indicates to the GUI environment that the application has
finished loading, using a given identifier.

GTK+ will call this function automatically for @/GtkWindow/@
with custom startup-notification identifier unless
@/gtk_window_set_auto_startup_notification()/@ is called to
disable that feature.

/Since: 3.0/
-}
displayNotifyStartupComplete ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> T.Text
    {- ^ /@startupId@/: a startup-notification identifier, for which
    notification process should be completed -}
    -> m ()
displayNotifyStartupComplete display startupId = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    startupId' <- textToCString startupId
    gdk_display_notify_startup_complete display' startupId'
    touchManagedPtr display
    freeMem startupId'
    return ()

#if ENABLE_OVERLOADING
data DisplayNotifyStartupCompleteMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplayNotifyStartupCompleteMethodInfo a signature where
    overloadedMethod _ = displayNotifyStartupComplete

#endif

-- method Display::peek_event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Event"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_peek_event" gdk_display_peek_event ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO (Ptr Gdk.Event.Event)

{- |
Gets a copy of the first 'GI.Gdk.Unions.Event.Event' in the /@display@/’s event queue, without
removing the event from the queue.  (Note that this function will
not get more events from the windowing system.  It only checks the events
that have already been moved to the GDK event queue.)

/Since: 2.2/
-}
displayPeekEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m (Maybe Gdk.Event.Event)
    {- ^ __Returns:__ a copy of the first 'GI.Gdk.Unions.Event.Event' on the event
queue, or 'Nothing' if no events are in the queue. The returned
'GI.Gdk.Unions.Event.Event' should be freed with 'GI.Gdk.Unions.Event.eventFree'. -}
displayPeekEvent display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_peek_event display'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Gdk.Event.Event) result'
        return result''
    touchManagedPtr display
    return maybeResult

#if ENABLE_OVERLOADING
data DisplayPeekEventMethodInfo
instance (signature ~ (m (Maybe Gdk.Event.Event)), MonadIO m, IsDisplay a) => O.MethodInfo DisplayPeekEventMethodInfo a signature where
    overloadedMethod _ = displayPeekEvent

#endif

-- method Display::pointer_is_grabbed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_pointer_is_grabbed" gdk_display_pointer_is_grabbed ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{-# DEPRECATED displayPointerIsGrabbed ["(Since version 3.0)","Use 'GI.Gdk.Objects.Display.displayDeviceIsGrabbed' instead."] #-}
{- |
Test if the pointer is grabbed.

/Since: 2.2/
-}
displayPointerIsGrabbed ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if an active X pointer grab is in effect -}
displayPointerIsGrabbed display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_pointer_is_grabbed display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplayPointerIsGrabbedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplayPointerIsGrabbedMethodInfo a signature where
    overloadedMethod _ = displayPointerIsGrabbed

#endif

-- method Display::pointer_ungrab
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timestap (e.g. %GDK_CURRENT_TIME).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_pointer_ungrab" gdk_display_pointer_ungrab ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Word32 ->                               -- time_ : TBasicType TUInt32
    IO ()

{-# DEPRECATED displayPointerUngrab ["(Since version 3.0)","Use 'GI.Gdk.Objects.Device.deviceUngrab', together with 'GI.Gdk.Objects.Device.deviceGrab'","            instead."] #-}
{- |
Release any pointer grab.

/Since: 2.2/
-}
displayPointerUngrab ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display'. -}
    -> Word32
    {- ^ /@time_@/: a timestap (e.g. 'GI.Gdk.Constants.CURRENT_TIME'). -}
    -> m ()
displayPointerUngrab display time_ = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_pointer_ungrab display' time_
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplayPointerUngrabMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplayPointerUngrabMethodInfo a signature where
    overloadedMethod _ = displayPointerUngrab

#endif

-- method Display::put_event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_put_event" gdk_display_put_event ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO ()

{- |
Appends a copy of the given event onto the front of the event
queue for /@display@/.

/Since: 2.2/
-}
displayPutEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event'. -}
    -> m ()
displayPutEvent display event = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    event' <- unsafeManagedPtrGetPtr event
    gdk_display_put_event display' event'
    touchManagedPtr display
    touchManagedPtr event
    return ()

#if ENABLE_OVERLOADING
data DisplayPutEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplayPutEventMethodInfo a signature where
    overloadedMethod _ = displayPutEvent

#endif

-- method Display::request_selection_notification
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkAtom naming the selection for which\n            ownership change notification is requested", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_request_selection_notification" gdk_display_request_selection_notification ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Gdk.Atom.Atom ->                    -- selection : TInterface (Name {namespace = "Gdk", name = "Atom"})
    IO CInt

{- |
Request 'GI.Gdk.Structs.EventOwnerChange.EventOwnerChange' events for ownership changes
of the selection named by the given atom.

/Since: 2.6/
-}
displayRequestSelectionNotification ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> Gdk.Atom.Atom
    {- ^ /@selection@/: the 'GI.Gdk.Structs.Atom.Atom' naming the selection for which
            ownership change notification is requested -}
    -> m Bool
    {- ^ __Returns:__ whether 'GI.Gdk.Structs.EventOwnerChange.EventOwnerChange' events will
              be sent. -}
displayRequestSelectionNotification display selection = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    selection' <- unsafeManagedPtrGetPtr selection
    result <- gdk_display_request_selection_notification display' selection'
    let result' = (/= 0) result
    touchManagedPtr display
    touchManagedPtr selection
    return result'

#if ENABLE_OVERLOADING
data DisplayRequestSelectionNotificationMethodInfo
instance (signature ~ (Gdk.Atom.Atom -> m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplayRequestSelectionNotificationMethodInfo a signature where
    overloadedMethod _ = displayRequestSelectionNotification

#endif

-- method Display::set_double_click_distance
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "distance", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "distance in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_set_double_click_distance" gdk_display_set_double_click_distance ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Word32 ->                               -- distance : TBasicType TUInt
    IO ()

{- |
Sets the double click distance (two clicks within this distance
count as a double click and result in a @/GDK_2BUTTON_PRESS/@ event).
See also 'GI.Gdk.Objects.Display.displaySetDoubleClickTime'.
Applications should not set this, it is a global
user-configured setting.

/Since: 2.4/
-}
displaySetDoubleClickDistance ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> Word32
    {- ^ /@distance@/: distance in pixels -}
    -> m ()
displaySetDoubleClickDistance display distance = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_set_double_click_distance display' distance
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplaySetDoubleClickDistanceMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySetDoubleClickDistanceMethodInfo a signature where
    overloadedMethod _ = displaySetDoubleClickDistance

#endif

-- method Display::set_double_click_time
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msec", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "double click time in milliseconds (thousandths of a second)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_set_double_click_time" gdk_display_set_double_click_time ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Word32 ->                               -- msec : TBasicType TUInt
    IO ()

{- |
Sets the double click time (two clicks within this time interval
count as a double click and result in a @/GDK_2BUTTON_PRESS/@ event).
Applications should not set this, it is a global
user-configured setting.

/Since: 2.2/
-}
displaySetDoubleClickTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> Word32
    {- ^ /@msec@/: double click time in milliseconds (thousandths of a second) -}
    -> m ()
displaySetDoubleClickTime display msec = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_set_double_click_time display' msec
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplaySetDoubleClickTimeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySetDoubleClickTimeMethodInfo a signature where
    overloadedMethod _ = displaySetDoubleClickTime

#endif

-- method Display::store_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clipboard_window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow belonging to the clipboard owner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timestamp", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "targets", argType = TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "Atom"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an array of targets\n                   that should be saved, or %NULL\n                   if all available targets should be saved.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of the @targets array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of the @targets array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_store_clipboard" gdk_display_store_clipboard ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Gdk.Window.Window ->                -- clipboard_window : TInterface (Name {namespace = "Gdk", name = "Window"})
    Word32 ->                               -- time_ : TBasicType TUInt32
    Ptr (Ptr Gdk.Atom.Atom) ->              -- targets : TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "Atom"}))
    Int32 ->                                -- n_targets : TBasicType TInt
    IO ()

{- |
Issues a request to the clipboard manager to store the
clipboard data. On X11, this is a special program that works
according to the
<http://www.freedesktop.org/Standards/clipboard-manager-spec FreeDesktop Clipboard Specification>.

/Since: 2.6/
-}
displayStoreClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a, Gdk.Window.IsWindow b) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> b
    {- ^ /@clipboardWindow@/: a 'GI.Gdk.Objects.Window.Window' belonging to the clipboard owner -}
    -> Word32
    {- ^ /@time_@/: a timestamp -}
    -> Maybe ([Gdk.Atom.Atom])
    {- ^ /@targets@/: an array of targets
                   that should be saved, or 'Nothing'
                   if all available targets should be saved. -}
    -> m ()
displayStoreClipboard display clipboardWindow time_ targets = liftIO $ do
    let nTargets = case targets of
            Nothing -> 0
            Just jTargets -> fromIntegral $ length jTargets
    display' <- unsafeManagedPtrCastPtr display
    clipboardWindow' <- unsafeManagedPtrCastPtr clipboardWindow
    maybeTargets <- case targets of
        Nothing -> return nullPtr
        Just jTargets -> do
            jTargets' <- mapM unsafeManagedPtrGetPtr jTargets
            jTargets'' <- packPtrArray jTargets'
            return jTargets''
    gdk_display_store_clipboard display' clipboardWindow' time_ maybeTargets nTargets
    touchManagedPtr display
    touchManagedPtr clipboardWindow
    whenJust targets (mapM_ touchManagedPtr)
    freeMem maybeTargets
    return ()

#if ENABLE_OVERLOADING
data DisplayStoreClipboardMethodInfo
instance (signature ~ (b -> Word32 -> Maybe ([Gdk.Atom.Atom]) -> m ()), MonadIO m, IsDisplay a, Gdk.Window.IsWindow b) => O.MethodInfo DisplayStoreClipboardMethodInfo a signature where
    overloadedMethod _ = displayStoreClipboard

#endif

-- method Display::supports_clipboard_persistence
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_supports_clipboard_persistence" gdk_display_supports_clipboard_persistence ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Returns whether the speicifed display supports clipboard
persistance; i.e. if it’s possible to store the clipboard data after an
application has quit. On X11 this checks if a clipboard daemon is
running.

/Since: 2.6/
-}
displaySupportsClipboardPersistence ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the display supports clipboard persistance. -}
displaySupportsClipboardPersistence display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_supports_clipboard_persistence display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplaySupportsClipboardPersistenceMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySupportsClipboardPersistenceMethodInfo a signature where
    overloadedMethod _ = displaySupportsClipboardPersistence

#endif

-- method Display::supports_composite
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_supports_composite" gdk_display_supports_composite ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{-# DEPRECATED displaySupportsComposite ["(Since version 3.16)","Compositing is an outdated technology that","  only ever worked on X11."] #-}
{- |
Returns 'True' if 'GI.Gdk.Objects.Window.windowSetComposited' can be used
to redirect drawing on the window using compositing.

Currently this only works on X11 with XComposite and
XDamage extensions available.

/Since: 2.12/
-}
displaySupportsComposite ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if windows may be composited. -}
displaySupportsComposite display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_supports_composite display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplaySupportsCompositeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySupportsCompositeMethodInfo a signature where
    overloadedMethod _ = displaySupportsComposite

#endif

-- method Display::supports_cursor_alpha
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_supports_cursor_alpha" gdk_display_supports_cursor_alpha ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Returns 'True' if cursors can use an 8bit alpha channel
on /@display@/. Otherwise, cursors are restricted to bilevel
alpha (i.e. a mask).

/Since: 2.4/
-}
displaySupportsCursorAlpha ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ whether cursors can have alpha channels. -}
displaySupportsCursorAlpha display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_supports_cursor_alpha display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplaySupportsCursorAlphaMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySupportsCursorAlphaMethodInfo a signature where
    overloadedMethod _ = displaySupportsCursorAlpha

#endif

-- method Display::supports_cursor_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_supports_cursor_color" gdk_display_supports_cursor_color ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Returns 'True' if multicolored cursors are supported
on /@display@/. Otherwise, cursors have only a forground
and a background color.

/Since: 2.4/
-}
displaySupportsCursorColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ whether cursors can have multiple colors. -}
displaySupportsCursorColor display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_supports_cursor_color display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplaySupportsCursorColorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySupportsCursorColorMethodInfo a signature where
    overloadedMethod _ = displaySupportsCursorColor

#endif

-- method Display::supports_input_shapes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_supports_input_shapes" gdk_display_supports_input_shapes ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Returns 'True' if @/gdk_window_input_shape_combine_mask()/@ can
be used to modify the input shape of windows on /@display@/.

/Since: 2.10/
-}
displaySupportsInputShapes ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if windows with modified input shape are supported -}
displaySupportsInputShapes display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_supports_input_shapes display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplaySupportsInputShapesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySupportsInputShapesMethodInfo a signature where
    overloadedMethod _ = displaySupportsInputShapes

#endif

-- method Display::supports_selection_notification
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_supports_selection_notification" gdk_display_supports_selection_notification ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Returns whether 'GI.Gdk.Structs.EventOwnerChange.EventOwnerChange' events will be
sent when the owner of a selection changes.

/Since: 2.6/
-}
displaySupportsSelectionNotification ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ whether 'GI.Gdk.Structs.EventOwnerChange.EventOwnerChange' events will
              be sent. -}
displaySupportsSelectionNotification display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_supports_selection_notification display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplaySupportsSelectionNotificationMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySupportsSelectionNotificationMethodInfo a signature where
    overloadedMethod _ = displaySupportsSelectionNotification

#endif

-- method Display::supports_shapes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_supports_shapes" gdk_display_supports_shapes ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO CInt

{- |
Returns 'True' if @/gdk_window_shape_combine_mask()/@ can
be used to create shaped windows on /@display@/.

/Since: 2.10/
-}
displaySupportsShapes ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if shaped windows are supported -}
displaySupportsShapes display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    result <- gdk_display_supports_shapes display'
    let result' = (/= 0) result
    touchManagedPtr display
    return result'

#if ENABLE_OVERLOADING
data DisplaySupportsShapesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySupportsShapesMethodInfo a signature where
    overloadedMethod _ = displaySupportsShapes

#endif

-- method Display::sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_sync" gdk_display_sync ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO ()

{- |
Flushes any requests queued for the windowing system and waits until all
requests have been handled. This is often used for making sure that the
display is synchronized with the current state of the program. Calling
'GI.Gdk.Objects.Display.displaySync' before 'GI.Gdk.Functions.errorTrapPop' makes sure that any errors
generated from earlier requests are handled before the error trap is
removed.

This is most useful for X11. On windowing systems where requests are
handled synchronously, this function will do nothing.

/Since: 2.2/
-}
displaySync ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> m ()
displaySync display = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    gdk_display_sync display'
    touchManagedPtr display
    return ()

#if ENABLE_OVERLOADING
data DisplaySyncMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDisplay a) => O.MethodInfo DisplaySyncMethodInfo a signature where
    overloadedMethod _ = displaySync

#endif

-- method Display::warp_pointer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the screen of @display to warp the pointer to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x coordinate of the destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y coordinate of the destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_warp_pointer" gdk_display_warp_pointer ::
    Ptr Display ->                          -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Gdk.Screen.Screen ->                -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    IO ()

{-# DEPRECATED displayWarpPointer ["(Since version 3.0)","Use 'GI.Gdk.Objects.Device.deviceWarp' instead."] #-}
{- |
Warps the pointer of /@display@/ to the point /@x@/,/@y@/ on
the screen /@screen@/, unless the pointer is confined
to a window by a grab, in which case it will be moved
as far as allowed by the grab. Warping the pointer
creates events as if the user had moved the mouse
instantaneously to the destination.

Note that the pointer should normally be under the
control of the user. This function was added to cover
some rare use cases like keyboard navigation support
for the color picker in the @/GtkColorSelectionDialog/@.

/Since: 2.8/
-}
displayWarpPointer ::
    (B.CallStack.HasCallStack, MonadIO m, IsDisplay a, Gdk.Screen.IsScreen b) =>
    a
    {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -}
    -> b
    {- ^ /@screen@/: the screen of /@display@/ to warp the pointer to -}
    -> Int32
    {- ^ /@x@/: the x coordinate of the destination -}
    -> Int32
    {- ^ /@y@/: the y coordinate of the destination -}
    -> m ()
displayWarpPointer display screen x y = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    screen' <- unsafeManagedPtrCastPtr screen
    gdk_display_warp_pointer display' screen' x y
    touchManagedPtr display
    touchManagedPtr screen
    return ()

#if ENABLE_OVERLOADING
data DisplayWarpPointerMethodInfo
instance (signature ~ (b -> Int32 -> Int32 -> m ()), MonadIO m, IsDisplay a, Gdk.Screen.IsScreen b) => O.MethodInfo DisplayWarpPointerMethodInfo a signature where
    overloadedMethod _ = displayWarpPointer

#endif

-- method Display::get_default
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Display"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_get_default" gdk_display_get_default ::
    IO (Ptr Display)

{- |
Gets the default 'GI.Gdk.Objects.Display.Display'. This is a convenience
function for:
@gdk_display_manager_get_default_display (gdk_display_manager_get ())@.

/Since: 2.2/
-}
displayGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe Display)
    {- ^ __Returns:__ a 'GI.Gdk.Objects.Display.Display', or 'Nothing' if
  there is no default display. -}
displayGetDefault  = liftIO $ do
    result <- gdk_display_get_default
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Display) result'
        return result''
    return maybeResult

#if ENABLE_OVERLOADING
#endif

-- method Display::open
-- method type : MemberFunction
-- Args : [Arg {argCName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the display to open", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Display"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_open" gdk_display_open ::
    CString ->                              -- display_name : TBasicType TUTF8
    IO (Ptr Display)

{- |
Opens a display.

/Since: 2.2/
-}
displayOpen ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@displayName@/: the name of the display to open -}
    -> m (Maybe Display)
    {- ^ __Returns:__ a 'GI.Gdk.Objects.Display.Display', or 'Nothing' if the
    display could not be opened -}
displayOpen displayName = liftIO $ do
    displayName' <- textToCString displayName
    result <- gdk_display_open displayName'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Display) result'
        return result''
    freeMem displayName'
    return maybeResult

#if ENABLE_OVERLOADING
#endif

-- method Display::open_default_libgtk_only
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Display"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_display_open_default_libgtk_only" gdk_display_open_default_libgtk_only ::
    IO (Ptr Display)

{-# DEPRECATED displayOpenDefaultLibgtkOnly ["(Since version 3.16)","This symbol was never meant to be used outside","  of GTK+"] #-}
{- |
Opens the default display specified by command line arguments or
environment variables, sets it as the default display, and returns
it. 'GI.Gdk.Functions.parseArgs' must have been called first. If the default
display has previously been set, simply returns that. An internal
function that should not be used by applications.
-}
displayOpenDefaultLibgtkOnly ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe Display)
    {- ^ __Returns:__ the default display, if it
  could be opened, otherwise 'Nothing'. -}
displayOpenDefaultLibgtkOnly  = liftIO $ do
    result <- gdk_display_open_default_libgtk_only
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Display) result'
        return result''
    return maybeResult

#if ENABLE_OVERLOADING
#endif