    {- |
    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.Screen.Screen' objects are the GDK representation of the screen on
    which windows can be displayed and on which the pointer moves.
    X originally identified screens with physical screens, but
    nowadays it is more common to have a single 'GI.Gdk.Objects.Screen.Screen' which
    combines several physical monitors (see 'GI.Gdk.Objects.Screen.screenGetNMonitors').

    GdkScreen is used throughout GDK and GTK+ to specify which screen
    the top level windows are to be displayed on. it is also used to
    query the screen specification and default settings such as
    the default visual ('GI.Gdk.Objects.Screen.screenGetSystemVisual'), the dimensions
    of the physical monitors ('GI.Gdk.Objects.Screen.screenGetMonitorGeometry'), etc.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gdk.Objects.Screen
        (

    -- * Exported types
        Screen(..)                              ,
        IsScreen                                ,
        toScreen                                ,
        noScreen                                ,

     -- * Methods
    -- ** getActiveWindow #method:getActiveWindow#

    #if ENABLE_OVERLOADING
        ScreenGetActiveWindowMethodInfo         ,
    #endif
        screenGetActiveWindow                   ,

    -- ** getDefault #method:getDefault#

        screenGetDefault                        ,

    -- ** getDisplay #method:getDisplay#

    #if ENABLE_OVERLOADING
        ScreenGetDisplayMethodInfo              ,
    #endif
        screenGetDisplay                        ,

    -- ** getFontOptions #method:getFontOptions#

    #if ENABLE_OVERLOADING
        ScreenGetFontOptionsMethodInfo          ,
    #endif
        screenGetFontOptions                    ,

    -- ** getHeight #method:getHeight#

    #if ENABLE_OVERLOADING
        ScreenGetHeightMethodInfo               ,
    #endif
        screenGetHeight                         ,

    -- ** getHeightMm #method:getHeightMm#

    #if ENABLE_OVERLOADING
        ScreenGetHeightMmMethodInfo             ,
    #endif
        screenGetHeightMm                       ,

    -- ** getMonitorAtPoint #method:getMonitorAtPoint#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorAtPointMethodInfo       ,
    #endif
        screenGetMonitorAtPoint                 ,

    -- ** getMonitorAtWindow #method:getMonitorAtWindow#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorAtWindowMethodInfo      ,
    #endif
        screenGetMonitorAtWindow                ,

    -- ** getMonitorGeometry #method:getMonitorGeometry#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorGeometryMethodInfo      ,
    #endif
        screenGetMonitorGeometry                ,

    -- ** getMonitorHeightMm #method:getMonitorHeightMm#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorHeightMmMethodInfo      ,
    #endif
        screenGetMonitorHeightMm                ,

    -- ** getMonitorPlugName #method:getMonitorPlugName#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorPlugNameMethodInfo      ,
    #endif
        screenGetMonitorPlugName                ,

    -- ** getMonitorScaleFactor #method:getMonitorScaleFactor#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorScaleFactorMethodInfo   ,
    #endif
        screenGetMonitorScaleFactor             ,

    -- ** getMonitorWidthMm #method:getMonitorWidthMm#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorWidthMmMethodInfo       ,
    #endif
        screenGetMonitorWidthMm                 ,

    -- ** getMonitorWorkarea #method:getMonitorWorkarea#

    #if ENABLE_OVERLOADING
        ScreenGetMonitorWorkareaMethodInfo      ,
    #endif
        screenGetMonitorWorkarea                ,

    -- ** getNMonitors #method:getNMonitors#

    #if ENABLE_OVERLOADING
        ScreenGetNMonitorsMethodInfo            ,
    #endif
        screenGetNMonitors                      ,

    -- ** getNumber #method:getNumber#

    #if ENABLE_OVERLOADING
        ScreenGetNumberMethodInfo               ,
    #endif
        screenGetNumber                         ,

    -- ** getPrimaryMonitor #method:getPrimaryMonitor#

    #if ENABLE_OVERLOADING
        ScreenGetPrimaryMonitorMethodInfo       ,
    #endif
        screenGetPrimaryMonitor                 ,

    -- ** getResolution #method:getResolution#

    #if ENABLE_OVERLOADING
        ScreenGetResolutionMethodInfo           ,
    #endif
        screenGetResolution                     ,

    -- ** getRgbaVisual #method:getRgbaVisual#

    #if ENABLE_OVERLOADING
        ScreenGetRgbaVisualMethodInfo           ,
    #endif
        screenGetRgbaVisual                     ,

    -- ** getRootWindow #method:getRootWindow#

    #if ENABLE_OVERLOADING
        ScreenGetRootWindowMethodInfo           ,
    #endif
        screenGetRootWindow                     ,

    -- ** getSetting #method:getSetting#

    #if ENABLE_OVERLOADING
        ScreenGetSettingMethodInfo              ,
    #endif
        screenGetSetting                        ,

    -- ** getSystemVisual #method:getSystemVisual#

    #if ENABLE_OVERLOADING
        ScreenGetSystemVisualMethodInfo         ,
    #endif
        screenGetSystemVisual                   ,

    -- ** getToplevelWindows #method:getToplevelWindows#

    #if ENABLE_OVERLOADING
        ScreenGetToplevelWindowsMethodInfo      ,
    #endif
        screenGetToplevelWindows                ,

    -- ** getWidth #method:getWidth#

    #if ENABLE_OVERLOADING
        ScreenGetWidthMethodInfo                ,
    #endif
        screenGetWidth                          ,

    -- ** getWidthMm #method:getWidthMm#

    #if ENABLE_OVERLOADING
        ScreenGetWidthMmMethodInfo              ,
    #endif
        screenGetWidthMm                        ,

    -- ** getWindowStack #method:getWindowStack#

    #if ENABLE_OVERLOADING
        ScreenGetWindowStackMethodInfo          ,
    #endif
        screenGetWindowStack                    ,

    -- ** height #method:height#

        screenHeight                            ,

    -- ** heightMm #method:heightMm#

        screenHeightMm                          ,

    -- ** isComposited #method:isComposited#

    #if ENABLE_OVERLOADING
        ScreenIsCompositedMethodInfo            ,
    #endif
        screenIsComposited                      ,

    -- ** listVisuals #method:listVisuals#

    #if ENABLE_OVERLOADING
        ScreenListVisualsMethodInfo             ,
    #endif
        screenListVisuals                       ,

    -- ** makeDisplayName #method:makeDisplayName#

    #if ENABLE_OVERLOADING
        ScreenMakeDisplayNameMethodInfo         ,
    #endif
        screenMakeDisplayName                   ,

    -- ** setFontOptions #method:setFontOptions#

    #if ENABLE_OVERLOADING
        ScreenSetFontOptionsMethodInfo          ,
    #endif
        screenSetFontOptions                    ,

    -- ** setResolution #method:setResolution#

    #if ENABLE_OVERLOADING
        ScreenSetResolutionMethodInfo           ,
    #endif
        screenSetResolution                     ,

    -- ** width #method:width#

        screenWidth                             ,

    -- ** widthMm #method:widthMm#

        screenWidthMm                           ,

     -- * Properties
    -- ** fontOptions #attr:fontOptions#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ScreenFontOptionsPropertyInfo           ,
    #endif
        constructScreenFontOptions              ,
        getScreenFontOptions                    ,
    #if ENABLE_OVERLOADING
        screenFontOptions                       ,
    #endif
        setScreenFontOptions                    ,

    -- ** resolution #attr:resolution#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ScreenResolutionPropertyInfo            ,
    #endif
        constructScreenResolution               ,
        getScreenResolution                     ,
    #if ENABLE_OVERLOADING
        screenResolution                        ,
    #endif
        setScreenResolution                     ,

     -- * Signals
    -- ** compositedChanged #signal:compositedChanged#

        C_ScreenCompositedChangedCallback       ,
        ScreenCompositedChangedCallback         ,
    #if ENABLE_OVERLOADING
        ScreenCompositedChangedSignalInfo       ,
    #endif
        afterScreenCompositedChanged            ,
        genClosure_ScreenCompositedChanged      ,
        mk_ScreenCompositedChangedCallback      ,
        noScreenCompositedChangedCallback       ,
        onScreenCompositedChanged               ,
        wrap_ScreenCompositedChangedCallback    ,

    -- ** monitorsChanged #signal:monitorsChanged#

        C_ScreenMonitorsChangedCallback         ,
        ScreenMonitorsChangedCallback           ,
    #if ENABLE_OVERLOADING
        ScreenMonitorsChangedSignalInfo         ,
    #endif
        afterScreenMonitorsChanged              ,
        genClosure_ScreenMonitorsChanged        ,
        mk_ScreenMonitorsChangedCallback        ,
        noScreenMonitorsChangedCallback         ,
        onScreenMonitorsChanged                 ,
        wrap_ScreenMonitorsChangedCallback      ,

    -- ** sizeChanged #signal:sizeChanged#

        C_ScreenSizeChangedCallback             ,
        ScreenSizeChangedCallback               ,
    #if ENABLE_OVERLOADING
        ScreenSizeChangedSignalInfo             ,
    #endif
        afterScreenSizeChanged                  ,
        genClosure_ScreenSizeChanged            ,
        mk_ScreenSizeChangedCallback            ,
        noScreenSizeChangedCallback             ,
        onScreenSizeChanged                     ,
        wrap_ScreenSizeChangedCallback          ,

        ) 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.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Visual as Gdk.Visual
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
    import {-# SOURCE #-} qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle

    -- | Memory-managed wrapper type.
    newtype Screen = Screen (ManagedPtr Screen)
    foreign import ccall "gdk_screen_get_type"
        c_gdk_screen_get_type :: IO GType

    instance GObject Screen where
        gobjectType _ = c_gdk_screen_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `Screen`.
    noScreen :: Maybe Screen
    noScreen = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveScreenMethod (t :: Symbol) (o :: *) :: * where
        ResolveScreenMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveScreenMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveScreenMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveScreenMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveScreenMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveScreenMethod "isComposited" o = ScreenIsCompositedMethodInfo
        ResolveScreenMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveScreenMethod "listVisuals" o = ScreenListVisualsMethodInfo
        ResolveScreenMethod "makeDisplayName" o = ScreenMakeDisplayNameMethodInfo
        ResolveScreenMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveScreenMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveScreenMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveScreenMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveScreenMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveScreenMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveScreenMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveScreenMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveScreenMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveScreenMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveScreenMethod "getActiveWindow" o = ScreenGetActiveWindowMethodInfo
        ResolveScreenMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveScreenMethod "getDisplay" o = ScreenGetDisplayMethodInfo
        ResolveScreenMethod "getFontOptions" o = ScreenGetFontOptionsMethodInfo
        ResolveScreenMethod "getHeight" o = ScreenGetHeightMethodInfo
        ResolveScreenMethod "getHeightMm" o = ScreenGetHeightMmMethodInfo
        ResolveScreenMethod "getMonitorAtPoint" o = ScreenGetMonitorAtPointMethodInfo
        ResolveScreenMethod "getMonitorAtWindow" o = ScreenGetMonitorAtWindowMethodInfo
        ResolveScreenMethod "getMonitorGeometry" o = ScreenGetMonitorGeometryMethodInfo
        ResolveScreenMethod "getMonitorHeightMm" o = ScreenGetMonitorHeightMmMethodInfo
        ResolveScreenMethod "getMonitorPlugName" o = ScreenGetMonitorPlugNameMethodInfo
        ResolveScreenMethod "getMonitorScaleFactor" o = ScreenGetMonitorScaleFactorMethodInfo
        ResolveScreenMethod "getMonitorWidthMm" o = ScreenGetMonitorWidthMmMethodInfo
        ResolveScreenMethod "getMonitorWorkarea" o = ScreenGetMonitorWorkareaMethodInfo
        ResolveScreenMethod "getNMonitors" o = ScreenGetNMonitorsMethodInfo
        ResolveScreenMethod "getNumber" o = ScreenGetNumberMethodInfo
        ResolveScreenMethod "getPrimaryMonitor" o = ScreenGetPrimaryMonitorMethodInfo
        ResolveScreenMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveScreenMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveScreenMethod "getResolution" o = ScreenGetResolutionMethodInfo
        ResolveScreenMethod "getRgbaVisual" o = ScreenGetRgbaVisualMethodInfo
        ResolveScreenMethod "getRootWindow" o = ScreenGetRootWindowMethodInfo
        ResolveScreenMethod "getSetting" o = ScreenGetSettingMethodInfo
        ResolveScreenMethod "getSystemVisual" o = ScreenGetSystemVisualMethodInfo
        ResolveScreenMethod "getToplevelWindows" o = ScreenGetToplevelWindowsMethodInfo
        ResolveScreenMethod "getWidth" o = ScreenGetWidthMethodInfo
        ResolveScreenMethod "getWidthMm" o = ScreenGetWidthMmMethodInfo
        ResolveScreenMethod "getWindowStack" o = ScreenGetWindowStackMethodInfo
        ResolveScreenMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveScreenMethod "setFontOptions" o = ScreenSetFontOptionsMethodInfo
        ResolveScreenMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveScreenMethod "setResolution" o = ScreenSetResolutionMethodInfo
        ResolveScreenMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveScreenMethod t Screen, O.MethodInfo info Screen p) => O.IsLabel t (Screen -> 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 Screen::composited-changed
    {- |
    The ::composited-changed signal is emitted when the composited
    status of the screen changes

    /Since: 2.10/
    -}
    type ScreenCompositedChangedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenCompositedChangedCallback`@.
    noScreenCompositedChangedCallback :: Maybe ScreenCompositedChangedCallback
    noScreenCompositedChangedCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ScreenCompositedChanged :: ScreenCompositedChangedCallback -> IO Closure
    genClosure_ScreenCompositedChanged cb = do
        let cb' = wrap_ScreenCompositedChangedCallback cb
        mk_ScreenCompositedChangedCallback cb' >>= newCClosure

    -- | Wrap a `ScreenCompositedChangedCallback` into a `C_ScreenCompositedChangedCallback`.
    wrap_ScreenCompositedChangedCallback ::
        ScreenCompositedChangedCallback ->
        C_ScreenCompositedChangedCallback
    wrap_ScreenCompositedChangedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@composited-changed@” 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' screen #compositedChanged callback
    @
    -}
    onScreenCompositedChanged :: (IsScreen a, MonadIO m) => a -> ScreenCompositedChangedCallback -> m SignalHandlerId
    onScreenCompositedChanged obj cb = liftIO $ do
        let cb' = wrap_ScreenCompositedChangedCallback cb
        cb'' <- mk_ScreenCompositedChangedCallback cb'
        connectSignalFunPtr obj "composited-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@composited-changed@” 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' screen #compositedChanged callback
    @
    -}
    afterScreenCompositedChanged :: (IsScreen a, MonadIO m) => a -> ScreenCompositedChangedCallback -> m SignalHandlerId
    afterScreenCompositedChanged obj cb = liftIO $ do
        let cb' = wrap_ScreenCompositedChangedCallback cb
        cb'' <- mk_ScreenCompositedChangedCallback cb'
        connectSignalFunPtr obj "composited-changed" cb'' SignalConnectAfter

    -- signal Screen::monitors-changed
    {- |
    The ::monitors-changed signal is emitted when the number, size
    or position of the monitors attached to the screen change.

    Only for X11 and OS X for now. A future implementation for Win32
    may be a possibility.

    /Since: 2.14/
    -}
    type ScreenMonitorsChangedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenMonitorsChangedCallback`@.
    noScreenMonitorsChangedCallback :: Maybe ScreenMonitorsChangedCallback
    noScreenMonitorsChangedCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ScreenMonitorsChanged :: ScreenMonitorsChangedCallback -> IO Closure
    genClosure_ScreenMonitorsChanged cb = do
        let cb' = wrap_ScreenMonitorsChangedCallback cb
        mk_ScreenMonitorsChangedCallback cb' >>= newCClosure

    -- | Wrap a `ScreenMonitorsChangedCallback` into a `C_ScreenMonitorsChangedCallback`.
    wrap_ScreenMonitorsChangedCallback ::
        ScreenMonitorsChangedCallback ->
        C_ScreenMonitorsChangedCallback
    wrap_ScreenMonitorsChangedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@monitors-changed@” 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' screen #monitorsChanged callback
    @
    -}
    onScreenMonitorsChanged :: (IsScreen a, MonadIO m) => a -> ScreenMonitorsChangedCallback -> m SignalHandlerId
    onScreenMonitorsChanged obj cb = liftIO $ do
        let cb' = wrap_ScreenMonitorsChangedCallback cb
        cb'' <- mk_ScreenMonitorsChangedCallback cb'
        connectSignalFunPtr obj "monitors-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@monitors-changed@” 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' screen #monitorsChanged callback
    @
    -}
    afterScreenMonitorsChanged :: (IsScreen a, MonadIO m) => a -> ScreenMonitorsChangedCallback -> m SignalHandlerId
    afterScreenMonitorsChanged obj cb = liftIO $ do
        let cb' = wrap_ScreenMonitorsChangedCallback cb
        cb'' <- mk_ScreenMonitorsChangedCallback cb'
        connectSignalFunPtr obj "monitors-changed" cb'' SignalConnectAfter

    -- signal Screen::size-changed
    {- |
    The ::size-changed signal is emitted when the pixel width or
    height of a screen changes.

    /Since: 2.2/
    -}
    type ScreenSizeChangedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenSizeChangedCallback`@.
    noScreenSizeChangedCallback :: Maybe ScreenSizeChangedCallback
    noScreenSizeChangedCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_ScreenSizeChanged :: ScreenSizeChangedCallback -> IO Closure
    genClosure_ScreenSizeChanged cb = do
        let cb' = wrap_ScreenSizeChangedCallback cb
        mk_ScreenSizeChangedCallback cb' >>= newCClosure

    -- | Wrap a `ScreenSizeChangedCallback` into a `C_ScreenSizeChangedCallback`.
    wrap_ScreenSizeChangedCallback ::
        ScreenSizeChangedCallback ->
        C_ScreenSizeChangedCallback
    wrap_ScreenSizeChangedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@size-changed@” 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' screen #sizeChanged callback
    @
    -}
    onScreenSizeChanged :: (IsScreen a, MonadIO m) => a -> ScreenSizeChangedCallback -> m SignalHandlerId
    onScreenSizeChanged obj cb = liftIO $ do
        let cb' = wrap_ScreenSizeChangedCallback cb
        cb'' <- mk_ScreenSizeChangedCallback cb'
        connectSignalFunPtr obj "size-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@size-changed@” 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' screen #sizeChanged callback
    @
    -}
    afterScreenSizeChanged :: (IsScreen a, MonadIO m) => a -> ScreenSizeChangedCallback -> m SignalHandlerId
    afterScreenSizeChanged obj cb = liftIO $ do
        let cb' = wrap_ScreenSizeChangedCallback cb
        cb'' <- mk_ScreenSizeChangedCallback cb'
        connectSignalFunPtr obj "size-changed" cb'' SignalConnectAfter

    -- VVV Prop "font-options"
       -- Type: TBasicType TPtr
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@font-options@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' screen #fontOptions
    @
    -}
    getScreenFontOptions :: (MonadIO m, IsScreen o) => o -> m (Ptr ())
    getScreenFontOptions obj = liftIO $ getObjectPropertyPtr obj "font-options"

    {- |
    Set the value of the “@font-options@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' screen [ #fontOptions 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScreenFontOptions :: (MonadIO m, IsScreen o) => o -> Ptr () -> m ()
    setScreenFontOptions obj val = liftIO $ setObjectPropertyPtr obj "font-options" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@font-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructScreenFontOptions :: (IsScreen o) => Ptr () -> IO (GValueConstruct o)
    constructScreenFontOptions val = constructObjectPropertyPtr "font-options" val

    #if ENABLE_OVERLOADING
    data ScreenFontOptionsPropertyInfo
    instance AttrInfo ScreenFontOptionsPropertyInfo where
        type AttrAllowedOps ScreenFontOptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint ScreenFontOptionsPropertyInfo = (~) (Ptr ())
        type AttrBaseTypeConstraint ScreenFontOptionsPropertyInfo = IsScreen
        type AttrGetType ScreenFontOptionsPropertyInfo = (Ptr ())
        type AttrLabel ScreenFontOptionsPropertyInfo = "font-options"
        type AttrOrigin ScreenFontOptionsPropertyInfo = Screen
        attrGet _ = getScreenFontOptions
        attrSet _ = setScreenFontOptions
        attrConstruct _ = constructScreenFontOptions
        attrClear _ = undefined
    #endif

    -- VVV Prop "resolution"
       -- Type: TBasicType TDouble
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@resolution@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' screen #resolution
    @
    -}
    getScreenResolution :: (MonadIO m, IsScreen o) => o -> m Double
    getScreenResolution obj = liftIO $ getObjectPropertyDouble obj "resolution"

    {- |
    Set the value of the “@resolution@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' screen [ #resolution 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScreenResolution :: (MonadIO m, IsScreen o) => o -> Double -> m ()
    setScreenResolution obj val = liftIO $ setObjectPropertyDouble obj "resolution" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@resolution@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructScreenResolution :: (IsScreen o) => Double -> IO (GValueConstruct o)
    constructScreenResolution val = constructObjectPropertyDouble "resolution" val

    #if ENABLE_OVERLOADING
    data ScreenResolutionPropertyInfo
    instance AttrInfo ScreenResolutionPropertyInfo where
        type AttrAllowedOps ScreenResolutionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint ScreenResolutionPropertyInfo = (~) Double
        type AttrBaseTypeConstraint ScreenResolutionPropertyInfo = IsScreen
        type AttrGetType ScreenResolutionPropertyInfo = Double
        type AttrLabel ScreenResolutionPropertyInfo = "resolution"
        type AttrOrigin ScreenResolutionPropertyInfo = Screen
        attrGet _ = getScreenResolution
        attrSet _ = setScreenResolution
        attrConstruct _ = constructScreenResolution
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Screen
    type instance O.AttributeList Screen = ScreenAttributeList
    type ScreenAttributeList = ('[ '("fontOptions", ScreenFontOptionsPropertyInfo), '("resolution", ScreenResolutionPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    screenFontOptions :: AttrLabelProxy "fontOptions"
    screenFontOptions = AttrLabelProxy

    screenResolution :: AttrLabelProxy "resolution"
    screenResolution = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    data ScreenCompositedChangedSignalInfo
    instance SignalInfo ScreenCompositedChangedSignalInfo where
        type HaskellCallbackType ScreenCompositedChangedSignalInfo = ScreenCompositedChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ScreenCompositedChangedCallback cb
            cb'' <- mk_ScreenCompositedChangedCallback cb'
            connectSignalFunPtr obj "composited-changed" cb'' connectMode

    data ScreenMonitorsChangedSignalInfo
    instance SignalInfo ScreenMonitorsChangedSignalInfo where
        type HaskellCallbackType ScreenMonitorsChangedSignalInfo = ScreenMonitorsChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ScreenMonitorsChangedCallback cb
            cb'' <- mk_ScreenMonitorsChangedCallback cb'
            connectSignalFunPtr obj "monitors-changed" cb'' connectMode

    data ScreenSizeChangedSignalInfo
    instance SignalInfo ScreenSizeChangedSignalInfo where
        type HaskellCallbackType ScreenSizeChangedSignalInfo = ScreenSizeChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ScreenSizeChangedCallback cb
            cb'' <- mk_ScreenSizeChangedCallback cb'
            connectSignalFunPtr obj "size-changed" cb'' connectMode

    type instance O.SignalList Screen = ScreenSignalList
    type ScreenSignalList = ('[ '("compositedChanged", ScreenCompositedChangedSignalInfo), '("monitorsChanged", ScreenMonitorsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sizeChanged", ScreenSizeChangedSignalInfo)] :: [(Symbol, *)])

    #endif

    -- method Screen::get_active_window
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_active_window" gdk_screen_get_active_window ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr Gdk.Window.Window)

    {-# DEPRECATED screenGetActiveWindow ["(Since version 3.22)"] #-}
    {- |
    Returns the screen’s currently active window.

    On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property
    on the root window, as described in the
    <http://www.freedesktop.org/Standards/wm-spec Extended Window Manager Hints>.
    If there is no currently currently active
    window, or the window manager does not support the
    _NET_ACTIVE_WINDOW hint, this function returns 'Nothing'.

    On other platforms, this function may return 'Nothing', depending on whether
    it is implementable on that platform.

    The returned window should be unrefed using 'GI.GObject.Objects.Object.objectUnref' when
    no longer needed.

    /Since: 2.10/
    -}
    screenGetActiveWindow ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m (Maybe Gdk.Window.Window)
        {- ^ __Returns:__ the currently active window,
      or 'Nothing'. -}
    screenGetActiveWindow screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_active_window screen'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (wrapObject Gdk.Window.Window) result'
            return result''
        touchManagedPtr screen
        return maybeResult

    #if ENABLE_OVERLOADING
    data ScreenGetActiveWindowMethodInfo
    instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetActiveWindowMethodInfo a signature where
        overloadedMethod _ = screenGetActiveWindow

    #endif

    -- method Screen::get_display
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_display" gdk_screen_get_display ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr Gdk.Display.Display)

    {- |
    Gets the display to which the /@screen@/ belongs.

    /Since: 2.2/
    -}
    screenGetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Gdk.Display.Display
        {- ^ __Returns:__ the display to which /@screen@/ belongs -}
    screenGetDisplay screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_display screen'
        checkUnexpectedReturnNULL "screenGetDisplay" result
        result' <- (newObject Gdk.Display.Display) result
        touchManagedPtr screen
        return result'

    #if ENABLE_OVERLOADING
    data ScreenGetDisplayMethodInfo
    instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetDisplayMethodInfo a signature where
        overloadedMethod _ = screenGetDisplay

    #endif

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

    foreign import ccall "gdk_screen_get_font_options" gdk_screen_get_font_options ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr Cairo.FontOptions.FontOptions)

    {- |
    Gets any options previously set with 'GI.Gdk.Objects.Screen.screenSetFontOptions'.

    /Since: 2.10/
    -}
    screenGetFontOptions ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m (Maybe Cairo.FontOptions.FontOptions)
        {- ^ __Returns:__ the current font options, or 'Nothing' if no
     default font options have been set. -}
    screenGetFontOptions screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_font_options screen'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed Cairo.FontOptions.FontOptions) result'
            return result''
        touchManagedPtr screen
        return maybeResult

    #if ENABLE_OVERLOADING
    data ScreenGetFontOptionsMethodInfo
    instance (signature ~ (m (Maybe Cairo.FontOptions.FontOptions)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetFontOptionsMethodInfo a signature where
        overloadedMethod _ = screenGetFontOptions

    #endif

    -- method Screen::get_height
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_height" gdk_screen_get_height ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO Int32

    {-# DEPRECATED screenGetHeight ["(Since version 3.22)","Use per-monitor information instead"] #-}
    {- |
    Gets the height of /@screen@/ in pixels. The returned size is in
    ”application pixels”, not in ”device pixels” (see
    'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').

    /Since: 2.2/
    -}
    screenGetHeight ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Int32
        {- ^ __Returns:__ the height of /@screen@/ in pixels. -}
    screenGetHeight screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_height screen'
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetHeightMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetHeightMethodInfo a signature where
        overloadedMethod _ = screenGetHeight

    #endif

    -- method Screen::get_height_mm
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_height_mm" gdk_screen_get_height_mm ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO Int32

    {-# DEPRECATED screenGetHeightMm ["(Since version 3.22)","Use per-monitor information instead"] #-}
    {- |
    Returns the height of /@screen@/ in millimeters.

    Note that this value is somewhat ill-defined when the screen
    has multiple monitors of different resolution. It is recommended
    to use the monitor dimensions instead.

    /Since: 2.2/
    -}
    screenGetHeightMm ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Int32
        {- ^ __Returns:__ the heigth of /@screen@/ in millimeters. -}
    screenGetHeightMm screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_height_mm screen'
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetHeightMmMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetHeightMmMethodInfo a signature where
        overloadedMethod _ = screenGetHeightMm

    #endif

    -- method Screen::get_monitor_at_point
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen.", 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 in the virtual screen.", 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 in the virtual screen.", 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_screen_get_monitor_at_point" gdk_screen_get_monitor_at_point ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        IO Int32

    {-# DEPRECATED screenGetMonitorAtPoint ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetMonitorAtPoint' instead"] #-}
    {- |
    Returns the monitor number in which the point (/@x@/,/@y@/) is located.

    /Since: 2.2/
    -}
    screenGetMonitorAtPoint ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
        -> Int32
        {- ^ /@x@/: the x coordinate in the virtual screen. -}
        -> Int32
        {- ^ /@y@/: the y coordinate in the virtual screen. -}
        -> m Int32
        {- ^ __Returns:__ the monitor number in which the point (/@x@/,/@y@/) lies, or
      a monitor close to (/@x@/,/@y@/) if the point is not in any monitor. -}
    screenGetMonitorAtPoint screen x y = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_monitor_at_point screen' x y
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorAtPointMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorAtPointMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorAtPoint

    #endif

    -- method Screen::get_monitor_at_window
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen.", 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 (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_get_monitor_at_window" gdk_screen_get_monitor_at_window ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
        IO Int32

    {-# DEPRECATED screenGetMonitorAtWindow ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetMonitorAtWindow' instead"] #-}
    {- |
    Returns the number of the monitor in which the largest area of the
    bounding rectangle of /@window@/ resides.

    /Since: 2.2/
    -}
    screenGetMonitorAtWindow ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a, Gdk.Window.IsWindow b) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
        -> b
        {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -}
        -> m Int32
        {- ^ __Returns:__ the monitor number in which most of /@window@/ is located,
        or if /@window@/ does not intersect any monitors, a monitor,
        close to /@window@/. -}
    screenGetMonitorAtWindow screen window = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        window' <- unsafeManagedPtrCastPtr window
        result <- gdk_screen_get_monitor_at_window screen' window'
        touchManagedPtr screen
        touchManagedPtr window
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorAtWindowMethodInfo
    instance (signature ~ (b -> m Int32), MonadIO m, IsScreen a, Gdk.Window.IsWindow b) => O.MethodInfo ScreenGetMonitorAtWindowMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorAtWindow

    #endif

    -- method Screen::get_monitor_geometry
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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 "the monitor number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle to be filled with\n    the monitor geometry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_get_monitor_geometry" gdk_screen_get_monitor_geometry ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- monitor_num : TBasicType TInt
        Ptr Gdk.Rectangle.Rectangle ->          -- dest : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
        IO ()

    {-# DEPRECATED screenGetMonitorGeometry ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetGeometry' instead"] #-}
    {- |
    Retrieves the 'GI.Gdk.Structs.Rectangle.Rectangle' representing the size and position of
    the individual monitor within the entire screen area. The returned
    geometry is in ”application pixels”, not in ”device pixels” (see
    'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').

    Monitor numbers start at 0. To obtain the number of monitors of
    /@screen@/, use 'GI.Gdk.Objects.Screen.screenGetNMonitors'.

    Note that the size of the entire screen area can be retrieved via
    'GI.Gdk.Objects.Screen.screenGetWidth' and 'GI.Gdk.Objects.Screen.screenGetHeight'.

    /Since: 2.2/
    -}
    screenGetMonitorGeometry ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> Int32
        {- ^ /@monitorNum@/: the monitor number -}
        -> m (Gdk.Rectangle.Rectangle)
    screenGetMonitorGeometry screen monitorNum = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        dest <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
        gdk_screen_get_monitor_geometry screen' monitorNum dest
        dest' <- (wrapBoxed Gdk.Rectangle.Rectangle) dest
        touchManagedPtr screen
        return dest'

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorGeometryMethodInfo
    instance (signature ~ (Int32 -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorGeometryMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorGeometry

    #endif

    -- method Screen::get_monitor_height_mm
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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, between 0 and gdk_screen_get_n_monitors (screen)", 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_screen_get_monitor_height_mm" gdk_screen_get_monitor_height_mm ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- monitor_num : TBasicType TInt
        IO Int32

    {-# DEPRECATED screenGetMonitorHeightMm ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetHeightMm' instead"] #-}
    {- |
    Gets the height in millimeters of the specified monitor.

    /Since: 2.14/
    -}
    screenGetMonitorHeightMm ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> Int32
        {- ^ /@monitorNum@/: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) -}
        -> m Int32
        {- ^ __Returns:__ the height of the monitor, or -1 if not available -}
    screenGetMonitorHeightMm screen monitorNum = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_monitor_height_mm screen' monitorNum
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorHeightMmMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorHeightMmMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorHeightMm

    #endif

    -- method Screen::get_monitor_plug_name
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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, between 0 and gdk_screen_get_n_monitors (screen)", 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_screen_get_monitor_plug_name" gdk_screen_get_monitor_plug_name ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- monitor_num : TBasicType TInt
        IO CString

    {-# DEPRECATED screenGetMonitorPlugName ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetModel' instead"] #-}
    {- |
    Returns the output name of the specified monitor.
    Usually something like VGA, DVI, or TV, not the actual
    product name of the display device.

    /Since: 2.14/
    -}
    screenGetMonitorPlugName ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> Int32
        {- ^ /@monitorNum@/: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ a newly-allocated string containing the name
      of the monitor, or 'Nothing' if the name cannot be determined -}
    screenGetMonitorPlugName screen monitorNum = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_monitor_plug_name screen' monitorNum
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            freeMem result'
            return result''
        touchManagedPtr screen
        return maybeResult

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorPlugNameMethodInfo
    instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorPlugNameMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorPlugName

    #endif

    -- method Screen::get_monitor_scale_factor
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "screen to get scale factor for", 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, between 0 and gdk_screen_get_n_monitors (screen)", 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_screen_get_monitor_scale_factor" gdk_screen_get_monitor_scale_factor ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- monitor_num : TBasicType TInt
        IO Int32

    {-# DEPRECATED screenGetMonitorScaleFactor ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetScaleFactor' instead"] #-}
    {- |
    Returns the internal scale factor that maps from monitor coordinates
    to the actual device pixels. On traditional systems this is 1, but
    on very high density outputs this can be a higher value (often 2).

    This can be used if you want to create pixel based data for a
    particular monitor, but most of the time you’re drawing to a window
    where it is better to use 'GI.Gdk.Objects.Window.windowGetScaleFactor' instead.

    /Since: 3.10/
    -}
    screenGetMonitorScaleFactor ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: screen to get scale factor for -}
        -> Int32
        {- ^ /@monitorNum@/: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) -}
        -> m Int32
        {- ^ __Returns:__ the scale factor -}
    screenGetMonitorScaleFactor screen monitorNum = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_monitor_scale_factor screen' monitorNum
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorScaleFactorMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorScaleFactorMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorScaleFactor

    #endif

    -- method Screen::get_monitor_width_mm
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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, between 0 and gdk_screen_get_n_monitors (screen)", 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_screen_get_monitor_width_mm" gdk_screen_get_monitor_width_mm ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- monitor_num : TBasicType TInt
        IO Int32

    {-# DEPRECATED screenGetMonitorWidthMm ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetWidthMm' instead"] #-}
    {- |
    Gets the width in millimeters of the specified monitor, if available.

    /Since: 2.14/
    -}
    screenGetMonitorWidthMm ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> Int32
        {- ^ /@monitorNum@/: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) -}
        -> m Int32
        {- ^ __Returns:__ the width of the monitor, or -1 if not available -}
    screenGetMonitorWidthMm screen monitorNum = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_monitor_width_mm screen' monitorNum
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorWidthMmMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorWidthMmMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorWidthMm

    #endif

    -- method Screen::get_monitor_workarea
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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 "the monitor number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle to be filled with\n    the monitor workarea", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_get_monitor_workarea" gdk_screen_get_monitor_workarea ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- monitor_num : TBasicType TInt
        Ptr Gdk.Rectangle.Rectangle ->          -- dest : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
        IO ()

    {-# DEPRECATED screenGetMonitorWorkarea ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetWorkarea' instead"] #-}
    {- |
    Retrieves the 'GI.Gdk.Structs.Rectangle.Rectangle' representing the size and position of
    the “work area” on a monitor within the entire screen area. The returned
    geometry is in ”application pixels”, not in ”device pixels” (see
    'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').

    The work area should be considered when positioning menus and
    similar popups, to avoid placing them below panels, docks or other
    desktop components.

    Note that not all backends may have a concept of workarea. This
    function will return the monitor geometry if a workarea is not
    available, or does not apply.

    Monitor numbers start at 0. To obtain the number of monitors of
    /@screen@/, use 'GI.Gdk.Objects.Screen.screenGetNMonitors'.

    /Since: 3.4/
    -}
    screenGetMonitorWorkarea ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> Int32
        {- ^ /@monitorNum@/: the monitor number -}
        -> m (Gdk.Rectangle.Rectangle)
    screenGetMonitorWorkarea screen monitorNum = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        dest <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
        gdk_screen_get_monitor_workarea screen' monitorNum dest
        dest' <- (wrapBoxed Gdk.Rectangle.Rectangle) dest
        touchManagedPtr screen
        return dest'

    #if ENABLE_OVERLOADING
    data ScreenGetMonitorWorkareaMethodInfo
    instance (signature ~ (Int32 -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorWorkareaMethodInfo a signature where
        overloadedMethod _ = screenGetMonitorWorkarea

    #endif

    -- method Screen::get_n_monitors
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_n_monitors" gdk_screen_get_n_monitors ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO Int32

    {-# DEPRECATED screenGetNMonitors ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetNMonitors' instead"] #-}
    {- |
    Returns the number of monitors which /@screen@/ consists of.

    /Since: 2.2/
    -}
    screenGetNMonitors ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Int32
        {- ^ __Returns:__ number of monitors which /@screen@/ consists of -}
    screenGetNMonitors screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_n_monitors screen'
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetNMonitorsMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetNMonitorsMethodInfo a signature where
        overloadedMethod _ = screenGetNMonitors

    #endif

    -- method Screen::get_number
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_number" gdk_screen_get_number ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO Int32

    {-# DEPRECATED screenGetNumber ["(Since version 3.22)"] #-}
    {- |
    Gets the index of /@screen@/ among the screens in the display
    to which it belongs. (See 'GI.Gdk.Objects.Screen.screenGetDisplay')

    /Since: 2.2/
    -}
    screenGetNumber ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Int32
        {- ^ __Returns:__ the index -}
    screenGetNumber screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_number screen'
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetNumberMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetNumberMethodInfo a signature where
        overloadedMethod _ = screenGetNumber

    #endif

    -- method Screen::get_primary_monitor
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen.", 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_screen_get_primary_monitor" gdk_screen_get_primary_monitor ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO Int32

    {-# DEPRECATED screenGetPrimaryMonitor ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetPrimaryMonitor' instead"] #-}
    {- |
    Gets the primary monitor for /@screen@/.  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.

    If no primary monitor is configured by the user, the return value
    will be 0, defaulting to the first monitor.

    /Since: 2.20/
    -}
    screenGetPrimaryMonitor ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
        -> m Int32
        {- ^ __Returns:__ An integer index for the primary monitor, or 0 if none is configured. -}
    screenGetPrimaryMonitor screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_primary_monitor screen'
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetPrimaryMonitorMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetPrimaryMonitorMethodInfo a signature where
        overloadedMethod _ = screenGetPrimaryMonitor

    #endif

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

    foreign import ccall "gdk_screen_get_resolution" gdk_screen_get_resolution ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO CDouble

    {- |
    Gets the resolution for font handling on the screen; see
    'GI.Gdk.Objects.Screen.screenSetResolution' for full details.

    /Since: 2.10/
    -}
    screenGetResolution ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Double
        {- ^ __Returns:__ the current resolution, or -1 if no resolution
    has been set. -}
    screenGetResolution screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_resolution screen'
        let result' = realToFrac result
        touchManagedPtr screen
        return result'

    #if ENABLE_OVERLOADING
    data ScreenGetResolutionMethodInfo
    instance (signature ~ (m Double), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetResolutionMethodInfo a signature where
        overloadedMethod _ = screenGetResolution

    #endif

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

    foreign import ccall "gdk_screen_get_rgba_visual" gdk_screen_get_rgba_visual ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr Gdk.Visual.Visual)

    {- |
    Gets a visual to use for creating windows with an alpha channel.
    The windowing system on which GTK+ is running
    may not support this capability, in which case 'Nothing' will
    be returned. Even if a non-'Nothing' value is returned, its
    possible that the window’s alpha channel won’t be honored
    when displaying the window on the screen: in particular, for
    X an appropriate windowing manager and compositing manager
    must be running to provide appropriate display.

    This functionality is not implemented in the Windows backend.

    For setting an overall opacity for a top-level window, see
    'GI.Gdk.Objects.Window.windowSetOpacity'.

    /Since: 2.8/
    -}
    screenGetRgbaVisual ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m (Maybe Gdk.Visual.Visual)
        {- ^ __Returns:__ a visual to use for windows
        with an alpha channel or 'Nothing' if the capability is not
        available. -}
    screenGetRgbaVisual screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_rgba_visual screen'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Gdk.Visual.Visual) result'
            return result''
        touchManagedPtr screen
        return maybeResult

    #if ENABLE_OVERLOADING
    data ScreenGetRgbaVisualMethodInfo
    instance (signature ~ (m (Maybe Gdk.Visual.Visual)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetRgbaVisualMethodInfo a signature where
        overloadedMethod _ = screenGetRgbaVisual

    #endif

    -- method Screen::get_root_window
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_root_window" gdk_screen_get_root_window ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr Gdk.Window.Window)

    {- |
    Gets the root window of /@screen@/.

    /Since: 2.2/
    -}
    screenGetRootWindow ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Gdk.Window.Window
        {- ^ __Returns:__ the root window -}
    screenGetRootWindow screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_root_window screen'
        checkUnexpectedReturnNULL "screenGetRootWindow" result
        result' <- (newObject Gdk.Window.Window) result
        touchManagedPtr screen
        return result'

    #if ENABLE_OVERLOADING
    data ScreenGetRootWindowMethodInfo
    instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetRootWindowMethodInfo a signature where
        overloadedMethod _ = screenGetRootWindow

    #endif

    -- method Screen::get_setting
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkScreen where the setting is located", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the setting", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the value of the setting", 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_screen_get_setting" gdk_screen_get_setting ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        CString ->                              -- name : TBasicType TUTF8
        Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})
        IO CInt

    {- |
    Retrieves a desktop-wide setting such as double-click time
    for the 'GI.Gdk.Objects.Screen.Screen' /@screen@/.

    FIXME needs a list of valid settings here, or a link to
    more information.

    /Since: 2.2/
    -}
    screenGetSetting ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: the 'GI.Gdk.Objects.Screen.Screen' where the setting is located -}
        -> T.Text
        {- ^ /@name@/: the name of the setting -}
        -> GValue
        {- ^ /@value@/: location to store the value of the setting -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the setting existed and a value was stored
      in /@value@/, 'False' otherwise. -}
    screenGetSetting screen name value = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        name' <- textToCString name
        value' <- unsafeManagedPtrGetPtr value
        result <- gdk_screen_get_setting screen' name' value'
        let result' = (/= 0) result
        touchManagedPtr screen
        touchManagedPtr value
        freeMem name'
        return result'

    #if ENABLE_OVERLOADING
    data ScreenGetSettingMethodInfo
    instance (signature ~ (T.Text -> GValue -> m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetSettingMethodInfo a signature where
        overloadedMethod _ = screenGetSetting

    #endif

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

    foreign import ccall "gdk_screen_get_system_visual" gdk_screen_get_system_visual ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr Gdk.Visual.Visual)

    {- |
    Get the system’s default visual for /@screen@/.
    This is the visual for the root window of the display.
    The return value should not be freed.

    /Since: 2.2/
    -}
    screenGetSystemVisual ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
        -> m Gdk.Visual.Visual
        {- ^ __Returns:__ the system visual -}
    screenGetSystemVisual screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_system_visual screen'
        checkUnexpectedReturnNULL "screenGetSystemVisual" result
        result' <- (newObject Gdk.Visual.Visual) result
        touchManagedPtr screen
        return result'

    #if ENABLE_OVERLOADING
    data ScreenGetSystemVisualMethodInfo
    instance (signature ~ (m Gdk.Visual.Visual), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetSystemVisualMethodInfo a signature where
        overloadedMethod _ = screenGetSystemVisual

    #endif

    -- method Screen::get_toplevel_windows
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GdkScreen where the toplevels are located.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Window"})))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_get_toplevel_windows" gdk_screen_get_toplevel_windows ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr (GList (Ptr Gdk.Window.Window)))

    {- |
    Obtains a list of all toplevel windows known to GDK on the screen /@screen@/.
    A toplevel window is a child of the root window (see
    'GI.Gdk.Functions.getDefaultRootWindow').

    The returned list should be freed with @/g_list_free()/@, but
    its elements need not be freed.

    /Since: 2.2/
    -}
    screenGetToplevelWindows ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: The 'GI.Gdk.Objects.Screen.Screen' where the toplevels are located. -}
        -> m [Gdk.Window.Window]
        {- ^ __Returns:__
        list of toplevel windows, free with @/g_list_free()/@ -}
    screenGetToplevelWindows screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_toplevel_windows screen'
        result' <- unpackGList result
        result'' <- mapM (newObject Gdk.Window.Window) result'
        g_list_free result
        touchManagedPtr screen
        return result''

    #if ENABLE_OVERLOADING
    data ScreenGetToplevelWindowsMethodInfo
    instance (signature ~ (m [Gdk.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetToplevelWindowsMethodInfo a signature where
        overloadedMethod _ = screenGetToplevelWindows

    #endif

    -- method Screen::get_width
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_width" gdk_screen_get_width ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO Int32

    {-# DEPRECATED screenGetWidth ["(Since version 3.22)","Use per-monitor information instead"] #-}
    {- |
    Gets the width of /@screen@/ in pixels. The returned size is in
    ”application pixels”, not in ”device pixels” (see
    'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').

    /Since: 2.2/
    -}
    screenGetWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Int32
        {- ^ __Returns:__ the width of /@screen@/ in pixels. -}
    screenGetWidth screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_width screen'
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetWidthMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWidthMethodInfo a signature where
        overloadedMethod _ = screenGetWidth

    #endif

    -- method Screen::get_width_mm
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_get_width_mm" gdk_screen_get_width_mm ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO Int32

    {-# DEPRECATED screenGetWidthMm ["(Since version 3.22)","Use per-monitor information instead"] #-}
    {- |
    Gets the width of /@screen@/ in millimeters.

    Note that this value is somewhat ill-defined when the screen
    has multiple monitors of different resolution. It is recommended
    to use the monitor dimensions instead.

    /Since: 2.2/
    -}
    screenGetWidthMm ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Int32
        {- ^ __Returns:__ the width of /@screen@/ in millimeters. -}
    screenGetWidthMm screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_width_mm screen'
        touchManagedPtr screen
        return result

    #if ENABLE_OVERLOADING
    data ScreenGetWidthMmMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWidthMmMethodInfo a signature where
        overloadedMethod _ = screenGetWidthMm

    #endif

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

    foreign import ccall "gdk_screen_get_window_stack" gdk_screen_get_window_stack ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr (GList (Ptr Gdk.Window.Window)))

    {- |
    Returns a 'GI.GLib.Structs.List.List' of @/GdkWindows/@ representing the current
    window stack.

    On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING
    property on the root window, as described in the
    <http://www.freedesktop.org/Standards/wm-spec Extended Window Manager Hints>.
    If the window manager does not support the
    _NET_CLIENT_LIST_STACKING hint, this function returns 'Nothing'.

    On other platforms, this function may return 'Nothing', depending on whether
    it is implementable on that platform.

    The returned list is newly allocated and owns references to the
    windows it contains, so it should be freed using @/g_list_free()/@ and
    its windows unrefed using 'GI.GObject.Objects.Object.objectUnref' when no longer needed.

    /Since: 2.10/
    -}
    screenGetWindowStack ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m [Gdk.Window.Window]
        {- ^ __Returns:__ a
        list of @/GdkWindows/@ for the current window stack, or 'Nothing'. -}
    screenGetWindowStack screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_get_window_stack screen'
        result' <- unpackGList result
        result'' <- mapM (wrapObject Gdk.Window.Window) result'
        g_list_free result
        touchManagedPtr screen
        return result''

    #if ENABLE_OVERLOADING
    data ScreenGetWindowStackMethodInfo
    instance (signature ~ (m [Gdk.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowStackMethodInfo a signature where
        overloadedMethod _ = screenGetWindowStack

    #endif

    -- method Screen::is_composited
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_is_composited" gdk_screen_is_composited ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO CInt

    {- |
    Returns whether windows with an RGBA visual can reasonably
    be expected to have their alpha channel drawn correctly on
    the screen.

    On X11 this function returns whether a compositing manager is
    compositing /@screen@/.

    /Since: 2.10/
    -}
    screenIsComposited ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m Bool
        {- ^ __Returns:__ Whether windows with RGBA visuals can reasonably be
    expected to have their alpha channels drawn correctly on the screen. -}
    screenIsComposited screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_is_composited screen'
        let result' = (/= 0) result
        touchManagedPtr screen
        return result'

    #if ENABLE_OVERLOADING
    data ScreenIsCompositedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenIsCompositedMethodInfo a signature where
        overloadedMethod _ = screenIsComposited

    #endif

    -- method Screen::list_visuals
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the relevant #GdkScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Visual"})))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_list_visuals" gdk_screen_list_visuals ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO (Ptr (GList (Ptr Gdk.Visual.Visual)))

    {- |
    Lists the available visuals for the specified /@screen@/.
    A visual describes a hardware image data format.
    For example, a visual might support 24-bit color, or 8-bit color,
    and might expect pixels to be in a certain format.

    Call @/g_list_free()/@ on the return value when you’re finished with it.

    /Since: 2.2/
    -}
    screenListVisuals ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: the relevant 'GI.Gdk.Objects.Screen.Screen'. -}
        -> m [Gdk.Visual.Visual]
        {- ^ __Returns:__
        a list of visuals; the list must be freed, but not its contents -}
    screenListVisuals screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_list_visuals screen'
        result' <- unpackGList result
        result'' <- mapM (newObject Gdk.Visual.Visual) result'
        g_list_free result
        touchManagedPtr screen
        return result''

    #if ENABLE_OVERLOADING
    data ScreenListVisualsMethodInfo
    instance (signature ~ (m [Gdk.Visual.Visual]), MonadIO m, IsScreen a) => O.MethodInfo ScreenListVisualsMethodInfo a signature where
        overloadedMethod _ = screenListVisuals

    #endif

    -- method Screen::make_display_name
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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_screen_make_display_name" gdk_screen_make_display_name ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        IO CString

    {-# DEPRECATED screenMakeDisplayName ["(Since version 3.22)"] #-}
    {- |
    Determines the name to pass to 'GI.Gdk.Objects.Display.displayOpen' to get
    a 'GI.Gdk.Objects.Display.Display' with this screen as the default screen.

    /Since: 2.2/
    -}
    screenMakeDisplayName ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> m T.Text
        {- ^ __Returns:__ a newly allocated string, free with 'GI.GLib.Functions.free' -}
    screenMakeDisplayName screen = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        result <- gdk_screen_make_display_name screen'
        checkUnexpectedReturnNULL "screenMakeDisplayName" result
        result' <- cstringToText result
        freeMem result
        touchManagedPtr screen
        return result'

    #if ENABLE_OVERLOADING
    data ScreenMakeDisplayNameMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsScreen a) => O.MethodInfo ScreenMakeDisplayNameMethodInfo a signature where
        overloadedMethod _ = screenMakeDisplayName

    #endif

    -- method Screen::set_font_options
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "cairo", name = "FontOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #cairo_font_options_t, or %NULL to unset any\n  previously set default font options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_set_font_options" gdk_screen_set_font_options ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Ptr Cairo.FontOptions.FontOptions ->    -- options : TInterface (Name {namespace = "cairo", name = "FontOptions"})
        IO ()

    {- |
    Sets the default font options for the screen. These
    options will be set on any 'GI.Pango.Objects.Context.Context'’s newly created
    with 'GI.Gdk.Functions.pangoContextGetForScreen'. Changing the
    default set of font options does not affect contexts that
    have already been created.

    /Since: 2.10/
    -}
    screenSetFontOptions ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> Maybe (Cairo.FontOptions.FontOptions)
        {- ^ /@options@/: a 'GI.Cairo.Structs.FontOptions.FontOptions', or 'Nothing' to unset any
      previously set default font options. -}
        -> m ()
    screenSetFontOptions screen options = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        maybeOptions <- case options of
            Nothing -> return nullPtr
            Just jOptions -> do
                jOptions' <- unsafeManagedPtrGetPtr jOptions
                return jOptions'
        gdk_screen_set_font_options screen' maybeOptions
        touchManagedPtr screen
        whenJust options touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data ScreenSetFontOptionsMethodInfo
    instance (signature ~ (Maybe (Cairo.FontOptions.FontOptions) -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenSetFontOptionsMethodInfo a signature where
        overloadedMethod _ = screenSetFontOptions

    #endif

    -- method Screen::set_resolution
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dpi", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the resolution in \8220dots per inch\8221. (Physical inches aren\8217t actually\n  involved; the terminology is conventional.)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_set_resolution" gdk_screen_set_resolution ::
        Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        CDouble ->                              -- dpi : TBasicType TDouble
        IO ()

    {- |
    Sets the resolution for font handling on the screen. This is a
    scale factor between points specified in a 'GI.Pango.Structs.FontDescription.FontDescription'
    and cairo units. The default value is 96, meaning that a 10 point
    font will be 13 units high. (10 * 96. \/ 72. = 13.3).

    /Since: 2.10/
    -}
    screenSetResolution ::
        (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
        a
        {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
        -> Double
        {- ^ /@dpi@/: the resolution in “dots per inch”. (Physical inches aren’t actually
      involved; the terminology is conventional.) -}
        -> m ()
    screenSetResolution screen dpi = liftIO $ do
        screen' <- unsafeManagedPtrCastPtr screen
        let dpi' = realToFrac dpi
        gdk_screen_set_resolution screen' dpi'
        touchManagedPtr screen
        return ()

    #if ENABLE_OVERLOADING
    data ScreenSetResolutionMethodInfo
    instance (signature ~ (Double -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenSetResolutionMethodInfo a signature where
        overloadedMethod _ = screenSetResolution

    #endif

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

    foreign import ccall "gdk_screen_get_default" gdk_screen_get_default ::
        IO (Ptr Screen)

    {- |
    Gets the default screen for the default display. (See
    gdk_display_get_default ()).

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

    #if ENABLE_OVERLOADING
    #endif

    -- method Screen::height
    -- method type : MemberFunction
    -- Args : []
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_height" gdk_screen_height ::
        IO Int32

    {-# DEPRECATED screenHeight ["(Since version 3.22)","Use per-monitor information"] #-}
    {- |
    Gets the height of the default screen in pixels. The returned
    size is in ”application pixels”, not in ”device pixels” (see
    'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
    -}
    screenHeight ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Int32
        {- ^ __Returns:__ the height of the default screen in pixels. -}
    screenHeight  = liftIO $ do
        result <- gdk_screen_height
        return result

    #if ENABLE_OVERLOADING
    #endif

    -- method Screen::height_mm
    -- method type : MemberFunction
    -- Args : []
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_height_mm" gdk_screen_height_mm ::
        IO Int32

    {-# DEPRECATED screenHeightMm ["(Since version 3.22)","Use per-monitor information"] #-}
    {- |
    Returns the height of the default screen in millimeters.
    Note that on many X servers this value will not be correct.
    -}
    screenHeightMm ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Int32
        {- ^ __Returns:__ the height of the default screen in millimeters,
    though it is not always correct. -}
    screenHeightMm  = liftIO $ do
        result <- gdk_screen_height_mm
        return result

    #if ENABLE_OVERLOADING
    #endif

    -- method Screen::width
    -- method type : MemberFunction
    -- Args : []
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_width" gdk_screen_width ::
        IO Int32

    {-# DEPRECATED screenWidth ["(Since version 3.22)","Use per-monitor information"] #-}
    {- |
    Gets the width of the default screen in pixels. The returned
    size is in ”application pixels”, not in ”device pixels” (see
    'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
    -}
    screenWidth ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Int32
        {- ^ __Returns:__ the width of the default screen in pixels. -}
    screenWidth  = liftIO $ do
        result <- gdk_screen_width
        return result

    #if ENABLE_OVERLOADING
    #endif

    -- method Screen::width_mm
    -- method type : MemberFunction
    -- Args : []
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_screen_width_mm" gdk_screen_width_mm ::
        IO Int32

    {-# DEPRECATED screenWidthMm ["(Since version 3.22)","Use per-monitor information"] #-}
    {- |
    Returns the width of the default screen in millimeters.
    Note that on many X servers this value will not be correct.
    -}
    screenWidthMm ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Int32
        {- ^ __Returns:__ the width of the default screen in millimeters,
    though it is not always correct. -}
    screenWidthMm  = liftIO $ do
        result <- gdk_screen_width_mm
        return result

    #if ENABLE_OVERLOADING
    #endif