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

    GdkMonitor objects represent the individual outputs that are
    associated with a 'GI.Gdk.Objects.Display.Display'. GdkDisplay has APIs to enumerate
    monitors with 'GI.Gdk.Objects.Display.displayGetNMonitors' and 'GI.Gdk.Objects.Display.displayGetMonitor', and
    to find particular monitors with 'GI.Gdk.Objects.Display.displayGetPrimaryMonitor' or
    'GI.Gdk.Objects.Display.displayGetMonitorAtWindow'.

    GdkMonitor was introduced in GTK+ 3.22 and supersedes earlier
    APIs in GdkScreen to obtain monitor-related information.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gdk.Objects.Monitor
        (

    -- * Exported types
        Monitor(..)                             ,
        IsMonitor                               ,
        toMonitor                               ,
        noMonitor                               ,

     -- * Methods
    -- ** getDisplay #method:getDisplay#

    #if ENABLE_OVERLOADING
        MonitorGetDisplayMethodInfo             ,
    #endif
        monitorGetDisplay                       ,

    -- ** getGeometry #method:getGeometry#

    #if ENABLE_OVERLOADING
        MonitorGetGeometryMethodInfo            ,
    #endif
        monitorGetGeometry                      ,

    -- ** getHeightMm #method:getHeightMm#

    #if ENABLE_OVERLOADING
        MonitorGetHeightMmMethodInfo            ,
    #endif
        monitorGetHeightMm                      ,

    -- ** getManufacturer #method:getManufacturer#

    #if ENABLE_OVERLOADING
        MonitorGetManufacturerMethodInfo        ,
    #endif
        monitorGetManufacturer                  ,

    -- ** getModel #method:getModel#

    #if ENABLE_OVERLOADING
        MonitorGetModelMethodInfo               ,
    #endif
        monitorGetModel                         ,

    -- ** getRefreshRate #method:getRefreshRate#

    #if ENABLE_OVERLOADING
        MonitorGetRefreshRateMethodInfo         ,
    #endif
        monitorGetRefreshRate                   ,

    -- ** getScaleFactor #method:getScaleFactor#

    #if ENABLE_OVERLOADING
        MonitorGetScaleFactorMethodInfo         ,
    #endif
        monitorGetScaleFactor                   ,

    -- ** getSubpixelLayout #method:getSubpixelLayout#

    #if ENABLE_OVERLOADING
        MonitorGetSubpixelLayoutMethodInfo      ,
    #endif
        monitorGetSubpixelLayout                ,

    -- ** getWidthMm #method:getWidthMm#

    #if ENABLE_OVERLOADING
        MonitorGetWidthMmMethodInfo             ,
    #endif
        monitorGetWidthMm                       ,

    -- ** getWorkarea #method:getWorkarea#

    #if ENABLE_OVERLOADING
        MonitorGetWorkareaMethodInfo            ,
    #endif
        monitorGetWorkarea                      ,

    -- ** isPrimary #method:isPrimary#

    #if ENABLE_OVERLOADING
        MonitorIsPrimaryMethodInfo              ,
    #endif
        monitorIsPrimary                        ,

     -- * Properties
    -- ** display #attr:display#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorDisplayPropertyInfo              ,
    #endif
        constructMonitorDisplay                 ,
        getMonitorDisplay                       ,
    #if ENABLE_OVERLOADING
        monitorDisplay                          ,
    #endif

    -- ** geometry #attr:geometry#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorGeometryPropertyInfo             ,
    #endif
        getMonitorGeometry                      ,
    #if ENABLE_OVERLOADING
        monitorGeometry                         ,
    #endif

    -- ** heightMm #attr:heightMm#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorHeightMmPropertyInfo             ,
    #endif
        getMonitorHeightMm                      ,
    #if ENABLE_OVERLOADING
        monitorHeightMm                         ,
    #endif

    -- ** manufacturer #attr:manufacturer#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorManufacturerPropertyInfo         ,
    #endif
        getMonitorManufacturer                  ,
    #if ENABLE_OVERLOADING
        monitorManufacturer                     ,
    #endif

    -- ** model #attr:model#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorModelPropertyInfo                ,
    #endif
        getMonitorModel                         ,
    #if ENABLE_OVERLOADING
        monitorModel                            ,
    #endif

    -- ** refreshRate #attr:refreshRate#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorRefreshRatePropertyInfo          ,
    #endif
        getMonitorRefreshRate                   ,
    #if ENABLE_OVERLOADING
        monitorRefreshRate                      ,
    #endif

    -- ** scaleFactor #attr:scaleFactor#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorScaleFactorPropertyInfo          ,
    #endif
        getMonitorScaleFactor                   ,
    #if ENABLE_OVERLOADING
        monitorScaleFactor                      ,
    #endif

    -- ** subpixelLayout #attr:subpixelLayout#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorSubpixelLayoutPropertyInfo       ,
    #endif
        getMonitorSubpixelLayout                ,
    #if ENABLE_OVERLOADING
        monitorSubpixelLayout                   ,
    #endif

    -- ** widthMm #attr:widthMm#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorWidthMmPropertyInfo              ,
    #endif
        getMonitorWidthMm                       ,
    #if ENABLE_OVERLOADING
        monitorWidthMm                          ,
    #endif

    -- ** workarea #attr:workarea#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        MonitorWorkareaPropertyInfo             ,
    #endif
        getMonitorWorkarea                      ,
    #if ENABLE_OVERLOADING
        monitorWorkarea                         ,
    #endif

     -- * Signals
    -- ** invalidate #signal:invalidate#

        C_MonitorInvalidateCallback             ,
        MonitorInvalidateCallback               ,
    #if ENABLE_OVERLOADING
        MonitorInvalidateSignalInfo             ,
    #endif
        afterMonitorInvalidate                  ,
        genClosure_MonitorInvalidate            ,
        mk_MonitorInvalidateCallback            ,
        noMonitorInvalidateCallback             ,
        onMonitorInvalidate                     ,
        wrap_MonitorInvalidateCallback          ,

        ) where

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

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

    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
    import {-# SOURCE #-} qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle

    -- | Memory-managed wrapper type.
    newtype Monitor = Monitor (ManagedPtr Monitor)
    foreign import ccall "gdk_monitor_get_type"
        c_gdk_monitor_get_type :: IO GType

    instance GObject Monitor where
        gobjectType _ = c_gdk_monitor_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `Monitor`.
    noMonitor :: Maybe Monitor
    noMonitor = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveMonitorMethod (t :: Symbol) (o :: *) :: * where
        ResolveMonitorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveMonitorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveMonitorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveMonitorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveMonitorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveMonitorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveMonitorMethod "isPrimary" o = MonitorIsPrimaryMethodInfo
        ResolveMonitorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveMonitorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveMonitorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveMonitorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveMonitorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveMonitorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveMonitorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveMonitorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveMonitorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveMonitorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveMonitorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveMonitorMethod "getDisplay" o = MonitorGetDisplayMethodInfo
        ResolveMonitorMethod "getGeometry" o = MonitorGetGeometryMethodInfo
        ResolveMonitorMethod "getHeightMm" o = MonitorGetHeightMmMethodInfo
        ResolveMonitorMethod "getManufacturer" o = MonitorGetManufacturerMethodInfo
        ResolveMonitorMethod "getModel" o = MonitorGetModelMethodInfo
        ResolveMonitorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveMonitorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveMonitorMethod "getRefreshRate" o = MonitorGetRefreshRateMethodInfo
        ResolveMonitorMethod "getScaleFactor" o = MonitorGetScaleFactorMethodInfo
        ResolveMonitorMethod "getSubpixelLayout" o = MonitorGetSubpixelLayoutMethodInfo
        ResolveMonitorMethod "getWidthMm" o = MonitorGetWidthMmMethodInfo
        ResolveMonitorMethod "getWorkarea" o = MonitorGetWorkareaMethodInfo
        ResolveMonitorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveMonitorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveMonitorMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveMonitorMethod t Monitor, O.MethodInfo info Monitor p) => O.IsLabel t (Monitor -> 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 Monitor::invalidate
    {- |
    /No description available in the introspection data./
    -}
    type MonitorInvalidateCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `MonitorInvalidateCallback`@.
    noMonitorInvalidateCallback :: Maybe MonitorInvalidateCallback
    noMonitorInvalidateCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_MonitorInvalidate :: MonitorInvalidateCallback -> IO Closure
    genClosure_MonitorInvalidate cb = do
        let cb' = wrap_MonitorInvalidateCallback cb
        mk_MonitorInvalidateCallback cb' >>= newCClosure

    -- | Wrap a `MonitorInvalidateCallback` into a `C_MonitorInvalidateCallback`.
    wrap_MonitorInvalidateCallback ::
        MonitorInvalidateCallback ->
        C_MonitorInvalidateCallback
    wrap_MonitorInvalidateCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@invalidate@” 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' monitor #invalidate callback
    @
    -}
    onMonitorInvalidate :: (IsMonitor a, MonadIO m) => a -> MonitorInvalidateCallback -> m SignalHandlerId
    onMonitorInvalidate obj cb = liftIO $ do
        let cb' = wrap_MonitorInvalidateCallback cb
        cb'' <- mk_MonitorInvalidateCallback cb'
        connectSignalFunPtr obj "invalidate" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@invalidate@” 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' monitor #invalidate callback
    @
    -}
    afterMonitorInvalidate :: (IsMonitor a, MonadIO m) => a -> MonitorInvalidateCallback -> m SignalHandlerId
    afterMonitorInvalidate obj cb = liftIO $ do
        let cb' = wrap_MonitorInvalidateCallback cb
        cb'' <- mk_MonitorInvalidateCallback cb'
        connectSignalFunPtr obj "invalidate" cb'' SignalConnectAfter

    -- VVV Prop "display"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Display"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #display
    @
    -}
    getMonitorDisplay :: (MonadIO m, IsMonitor o) => o -> m Gdk.Display.Display
    getMonitorDisplay obj = liftIO $ checkUnexpectedNothing "getMonitorDisplay" $ getObjectPropertyObject obj "display" Gdk.Display.Display

    {- |
    Construct a `GValueConstruct` with valid value for the “@display@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructMonitorDisplay :: (IsMonitor o, Gdk.Display.IsDisplay a) => a -> IO (GValueConstruct o)
    constructMonitorDisplay val = constructObjectPropertyObject "display" (Just val)

    #if ENABLE_OVERLOADING
    data MonitorDisplayPropertyInfo
    instance AttrInfo MonitorDisplayPropertyInfo where
        type AttrAllowedOps MonitorDisplayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MonitorDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrBaseTypeConstraint MonitorDisplayPropertyInfo = IsMonitor
        type AttrGetType MonitorDisplayPropertyInfo = Gdk.Display.Display
        type AttrLabel MonitorDisplayPropertyInfo = "display"
        type AttrOrigin MonitorDisplayPropertyInfo = Monitor
        attrGet _ = getMonitorDisplay
        attrSet _ = undefined
        attrConstruct _ = constructMonitorDisplay
        attrClear _ = undefined
    #endif

    -- VVV Prop "geometry"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Rectangle"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #geometry
    @
    -}
    getMonitorGeometry :: (MonadIO m, IsMonitor o) => o -> m (Maybe Gdk.Rectangle.Rectangle)
    getMonitorGeometry obj = liftIO $ getObjectPropertyBoxed obj "geometry" Gdk.Rectangle.Rectangle

    #if ENABLE_OVERLOADING
    data MonitorGeometryPropertyInfo
    instance AttrInfo MonitorGeometryPropertyInfo where
        type AttrAllowedOps MonitorGeometryPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MonitorGeometryPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorGeometryPropertyInfo = IsMonitor
        type AttrGetType MonitorGeometryPropertyInfo = (Maybe Gdk.Rectangle.Rectangle)
        type AttrLabel MonitorGeometryPropertyInfo = "geometry"
        type AttrOrigin MonitorGeometryPropertyInfo = Monitor
        attrGet _ = getMonitorGeometry
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "height-mm"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #heightMm
    @
    -}
    getMonitorHeightMm :: (MonadIO m, IsMonitor o) => o -> m Int32
    getMonitorHeightMm obj = liftIO $ getObjectPropertyInt32 obj "height-mm"

    #if ENABLE_OVERLOADING
    data MonitorHeightMmPropertyInfo
    instance AttrInfo MonitorHeightMmPropertyInfo where
        type AttrAllowedOps MonitorHeightMmPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint MonitorHeightMmPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorHeightMmPropertyInfo = IsMonitor
        type AttrGetType MonitorHeightMmPropertyInfo = Int32
        type AttrLabel MonitorHeightMmPropertyInfo = "height-mm"
        type AttrOrigin MonitorHeightMmPropertyInfo = Monitor
        attrGet _ = getMonitorHeightMm
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "manufacturer"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable]
       -- Nullable: (Just True,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #manufacturer
    @
    -}
    getMonitorManufacturer :: (MonadIO m, IsMonitor o) => o -> m (Maybe T.Text)
    getMonitorManufacturer obj = liftIO $ getObjectPropertyString obj "manufacturer"

    #if ENABLE_OVERLOADING
    data MonitorManufacturerPropertyInfo
    instance AttrInfo MonitorManufacturerPropertyInfo where
        type AttrAllowedOps MonitorManufacturerPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MonitorManufacturerPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorManufacturerPropertyInfo = IsMonitor
        type AttrGetType MonitorManufacturerPropertyInfo = (Maybe T.Text)
        type AttrLabel MonitorManufacturerPropertyInfo = "manufacturer"
        type AttrOrigin MonitorManufacturerPropertyInfo = Monitor
        attrGet _ = getMonitorManufacturer
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "model"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable]
       -- Nullable: (Just True,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #model
    @
    -}
    getMonitorModel :: (MonadIO m, IsMonitor o) => o -> m (Maybe T.Text)
    getMonitorModel obj = liftIO $ getObjectPropertyString obj "model"

    #if ENABLE_OVERLOADING
    data MonitorModelPropertyInfo
    instance AttrInfo MonitorModelPropertyInfo where
        type AttrAllowedOps MonitorModelPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MonitorModelPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorModelPropertyInfo = IsMonitor
        type AttrGetType MonitorModelPropertyInfo = (Maybe T.Text)
        type AttrLabel MonitorModelPropertyInfo = "model"
        type AttrOrigin MonitorModelPropertyInfo = Monitor
        attrGet _ = getMonitorModel
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "refresh-rate"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #refreshRate
    @
    -}
    getMonitorRefreshRate :: (MonadIO m, IsMonitor o) => o -> m Int32
    getMonitorRefreshRate obj = liftIO $ getObjectPropertyInt32 obj "refresh-rate"

    #if ENABLE_OVERLOADING
    data MonitorRefreshRatePropertyInfo
    instance AttrInfo MonitorRefreshRatePropertyInfo where
        type AttrAllowedOps MonitorRefreshRatePropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint MonitorRefreshRatePropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorRefreshRatePropertyInfo = IsMonitor
        type AttrGetType MonitorRefreshRatePropertyInfo = Int32
        type AttrLabel MonitorRefreshRatePropertyInfo = "refresh-rate"
        type AttrOrigin MonitorRefreshRatePropertyInfo = Monitor
        attrGet _ = getMonitorRefreshRate
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "scale-factor"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #scaleFactor
    @
    -}
    getMonitorScaleFactor :: (MonadIO m, IsMonitor o) => o -> m Int32
    getMonitorScaleFactor obj = liftIO $ getObjectPropertyInt32 obj "scale-factor"

    #if ENABLE_OVERLOADING
    data MonitorScaleFactorPropertyInfo
    instance AttrInfo MonitorScaleFactorPropertyInfo where
        type AttrAllowedOps MonitorScaleFactorPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint MonitorScaleFactorPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorScaleFactorPropertyInfo = IsMonitor
        type AttrGetType MonitorScaleFactorPropertyInfo = Int32
        type AttrLabel MonitorScaleFactorPropertyInfo = "scale-factor"
        type AttrOrigin MonitorScaleFactorPropertyInfo = Monitor
        attrGet _ = getMonitorScaleFactor
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "subpixel-layout"
       -- Type: TInterface (Name {namespace = "Gdk", name = "SubpixelLayout"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #subpixelLayout
    @
    -}
    getMonitorSubpixelLayout :: (MonadIO m, IsMonitor o) => o -> m Gdk.Enums.SubpixelLayout
    getMonitorSubpixelLayout obj = liftIO $ getObjectPropertyEnum obj "subpixel-layout"

    #if ENABLE_OVERLOADING
    data MonitorSubpixelLayoutPropertyInfo
    instance AttrInfo MonitorSubpixelLayoutPropertyInfo where
        type AttrAllowedOps MonitorSubpixelLayoutPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint MonitorSubpixelLayoutPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorSubpixelLayoutPropertyInfo = IsMonitor
        type AttrGetType MonitorSubpixelLayoutPropertyInfo = Gdk.Enums.SubpixelLayout
        type AttrLabel MonitorSubpixelLayoutPropertyInfo = "subpixel-layout"
        type AttrOrigin MonitorSubpixelLayoutPropertyInfo = Monitor
        attrGet _ = getMonitorSubpixelLayout
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "width-mm"
       -- Type: TBasicType TInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #widthMm
    @
    -}
    getMonitorWidthMm :: (MonadIO m, IsMonitor o) => o -> m Int32
    getMonitorWidthMm obj = liftIO $ getObjectPropertyInt32 obj "width-mm"

    #if ENABLE_OVERLOADING
    data MonitorWidthMmPropertyInfo
    instance AttrInfo MonitorWidthMmPropertyInfo where
        type AttrAllowedOps MonitorWidthMmPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint MonitorWidthMmPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorWidthMmPropertyInfo = IsMonitor
        type AttrGetType MonitorWidthMmPropertyInfo = Int32
        type AttrLabel MonitorWidthMmPropertyInfo = "width-mm"
        type AttrOrigin MonitorWidthMmPropertyInfo = Monitor
        attrGet _ = getMonitorWidthMm
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "workarea"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Rectangle"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' monitor #workarea
    @
    -}
    getMonitorWorkarea :: (MonadIO m, IsMonitor o) => o -> m (Maybe Gdk.Rectangle.Rectangle)
    getMonitorWorkarea obj = liftIO $ getObjectPropertyBoxed obj "workarea" Gdk.Rectangle.Rectangle

    #if ENABLE_OVERLOADING
    data MonitorWorkareaPropertyInfo
    instance AttrInfo MonitorWorkareaPropertyInfo where
        type AttrAllowedOps MonitorWorkareaPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MonitorWorkareaPropertyInfo = (~) ()
        type AttrBaseTypeConstraint MonitorWorkareaPropertyInfo = IsMonitor
        type AttrGetType MonitorWorkareaPropertyInfo = (Maybe Gdk.Rectangle.Rectangle)
        type AttrLabel MonitorWorkareaPropertyInfo = "workarea"
        type AttrOrigin MonitorWorkareaPropertyInfo = Monitor
        attrGet _ = getMonitorWorkarea
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Monitor
    type instance O.AttributeList Monitor = MonitorAttributeList
    type MonitorAttributeList = ('[ '("display", MonitorDisplayPropertyInfo), '("geometry", MonitorGeometryPropertyInfo), '("heightMm", MonitorHeightMmPropertyInfo), '("manufacturer", MonitorManufacturerPropertyInfo), '("model", MonitorModelPropertyInfo), '("refreshRate", MonitorRefreshRatePropertyInfo), '("scaleFactor", MonitorScaleFactorPropertyInfo), '("subpixelLayout", MonitorSubpixelLayoutPropertyInfo), '("widthMm", MonitorWidthMmPropertyInfo), '("workarea", MonitorWorkareaPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    monitorDisplay :: AttrLabelProxy "display"
    monitorDisplay = AttrLabelProxy

    monitorGeometry :: AttrLabelProxy "geometry"
    monitorGeometry = AttrLabelProxy

    monitorHeightMm :: AttrLabelProxy "heightMm"
    monitorHeightMm = AttrLabelProxy

    monitorManufacturer :: AttrLabelProxy "manufacturer"
    monitorManufacturer = AttrLabelProxy

    monitorModel :: AttrLabelProxy "model"
    monitorModel = AttrLabelProxy

    monitorRefreshRate :: AttrLabelProxy "refreshRate"
    monitorRefreshRate = AttrLabelProxy

    monitorScaleFactor :: AttrLabelProxy "scaleFactor"
    monitorScaleFactor = AttrLabelProxy

    monitorSubpixelLayout :: AttrLabelProxy "subpixelLayout"
    monitorSubpixelLayout = AttrLabelProxy

    monitorWidthMm :: AttrLabelProxy "widthMm"
    monitorWidthMm = AttrLabelProxy

    monitorWorkarea :: AttrLabelProxy "workarea"
    monitorWorkarea = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    data MonitorInvalidateSignalInfo
    instance SignalInfo MonitorInvalidateSignalInfo where
        type HaskellCallbackType MonitorInvalidateSignalInfo = MonitorInvalidateCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_MonitorInvalidateCallback cb
            cb'' <- mk_MonitorInvalidateCallback cb'
            connectSignalFunPtr obj "invalidate" cb'' connectMode

    type instance O.SignalList Monitor = MonitorSignalList
    type MonitorSignalList = ('[ '("invalidate", MonitorInvalidateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

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

    {- |
    Gets the display that this monitor belongs to.

    /Since: 3.22/
    -}
    monitorGetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m Gdk.Display.Display
        {- ^ __Returns:__ the display -}
    monitorGetDisplay monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_display monitor'
        checkUnexpectedReturnNULL "monitorGetDisplay" result
        result' <- (newObject Gdk.Display.Display) result
        touchManagedPtr monitor
        return result'

    #if ENABLE_OVERLOADING
    data MonitorGetDisplayMethodInfo
    instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetDisplayMethodInfo a signature where
        overloadedMethod _ = monitorGetDisplay

    #endif

    -- method Monitor::get_geometry
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkMonitor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "geometry", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle to be filled with 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_monitor_get_geometry" gdk_monitor_get_geometry ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        Ptr Gdk.Rectangle.Rectangle ->          -- geometry : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
        IO ()

    {- |
    Retrieves the size and position of an individual monitor within the
    display coordinate space. The returned geometry is in  ”application pixels”,
    not in ”device pixels” (see 'GI.Gdk.Objects.Monitor.monitorGetScaleFactor').

    /Since: 3.22/
    -}
    monitorGetGeometry ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m (Gdk.Rectangle.Rectangle)
    monitorGetGeometry monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        geometry <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
        gdk_monitor_get_geometry monitor' geometry
        geometry' <- (wrapBoxed Gdk.Rectangle.Rectangle) geometry
        touchManagedPtr monitor
        return geometry'

    #if ENABLE_OVERLOADING
    data MonitorGetGeometryMethodInfo
    instance (signature ~ (m (Gdk.Rectangle.Rectangle)), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetGeometryMethodInfo a signature where
        overloadedMethod _ = monitorGetGeometry

    #endif

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

    {- |
    Gets the height in millimeters of the monitor.

    /Since: 3.22/
    -}
    monitorGetHeightMm ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m Int32
        {- ^ __Returns:__ the physical height of the monitor -}
    monitorGetHeightMm monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_height_mm monitor'
        touchManagedPtr monitor
        return result

    #if ENABLE_OVERLOADING
    data MonitorGetHeightMmMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetHeightMmMethodInfo a signature where
        overloadedMethod _ = monitorGetHeightMm

    #endif

    -- method Monitor::get_manufacturer
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkMonitor", 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_monitor_get_manufacturer" gdk_monitor_get_manufacturer ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        IO CString

    {- |
    Gets the name or PNP ID of the monitor\'s manufacturer, if available.

    Note that this value might also vary depending on actual
    display backend.

    PNP ID registry is located at https:\/\/uefi.org\/pnp_id_list
    -}
    monitorGetManufacturer ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ the name of the manufacturer, or 'Nothing' -}
    monitorGetManufacturer monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_manufacturer monitor'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr monitor
        return maybeResult

    #if ENABLE_OVERLOADING
    data MonitorGetManufacturerMethodInfo
    instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetManufacturerMethodInfo a signature where
        overloadedMethod _ = monitorGetManufacturer

    #endif

    -- method Monitor::get_model
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkMonitor", 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_monitor_get_model" gdk_monitor_get_model ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        IO CString

    {- |
    Gets the a string identifying the monitor model, if available.
    -}
    monitorGetModel ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ the monitor model, or 'Nothing' -}
    monitorGetModel monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_model monitor'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr monitor
        return maybeResult

    #if ENABLE_OVERLOADING
    data MonitorGetModelMethodInfo
    instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetModelMethodInfo a signature where
        overloadedMethod _ = monitorGetModel

    #endif

    -- method Monitor::get_refresh_rate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkMonitor", 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_monitor_get_refresh_rate" gdk_monitor_get_refresh_rate ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        IO Int32

    {- |
    Gets the refresh rate of the monitor, if available.

    The value is in milli-Hertz, so a refresh rate of 60Hz
    is returned as 60000.

    /Since: 3.22/
    -}
    monitorGetRefreshRate ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m Int32
        {- ^ __Returns:__ the refresh rate in milli-Hertz, or 0 -}
    monitorGetRefreshRate monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_refresh_rate monitor'
        touchManagedPtr monitor
        return result

    #if ENABLE_OVERLOADING
    data MonitorGetRefreshRateMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetRefreshRateMethodInfo a signature where
        overloadedMethod _ = monitorGetRefreshRate

    #endif

    -- method Monitor::get_scale_factor
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkMonitor", 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_monitor_get_scale_factor" gdk_monitor_get_scale_factor ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        IO Int32

    {- |
    Gets 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.22/
    -}
    monitorGetScaleFactor ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m Int32
        {- ^ __Returns:__ the scale factor -}
    monitorGetScaleFactor monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_scale_factor monitor'
        touchManagedPtr monitor
        return result

    #if ENABLE_OVERLOADING
    data MonitorGetScaleFactorMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetScaleFactorMethodInfo a signature where
        overloadedMethod _ = monitorGetScaleFactor

    #endif

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

    foreign import ccall "gdk_monitor_get_subpixel_layout" gdk_monitor_get_subpixel_layout ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        IO CUInt

    {- |
    Gets information about the layout of red, green and blue
    primaries for each pixel in this monitor, if available.

    /Since: 3.22/
    -}
    monitorGetSubpixelLayout ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m Gdk.Enums.SubpixelLayout
        {- ^ __Returns:__ the subpixel layout -}
    monitorGetSubpixelLayout monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_subpixel_layout monitor'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr monitor
        return result'

    #if ENABLE_OVERLOADING
    data MonitorGetSubpixelLayoutMethodInfo
    instance (signature ~ (m Gdk.Enums.SubpixelLayout), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetSubpixelLayoutMethodInfo a signature where
        overloadedMethod _ = monitorGetSubpixelLayout

    #endif

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

    {- |
    Gets the width in millimeters of the monitor.

    /Since: 3.22/
    -}
    monitorGetWidthMm ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m Int32
        {- ^ __Returns:__ the physical width of the monitor -}
    monitorGetWidthMm monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_get_width_mm monitor'
        touchManagedPtr monitor
        return result

    #if ENABLE_OVERLOADING
    data MonitorGetWidthMmMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetWidthMmMethodInfo a signature where
        overloadedMethod _ = monitorGetWidthMm

    #endif

    -- method Monitor::get_workarea
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkMonitor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workarea", 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_monitor_get_workarea" gdk_monitor_get_workarea ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        Ptr Gdk.Rectangle.Rectangle ->          -- workarea : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
        IO ()

    {- |
    Retrieves the size and position of the “work area” on a monitor
    within the display coordinate space. The returned geometry is in
    ”application pixels”, not in ”device pixels” (see
    'GI.Gdk.Objects.Monitor.monitorGetScaleFactor').

    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.

    /Since: 3.22/
    -}
    monitorGetWorkarea ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m (Gdk.Rectangle.Rectangle)
    monitorGetWorkarea monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        workarea <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
        gdk_monitor_get_workarea monitor' workarea
        workarea' <- (wrapBoxed Gdk.Rectangle.Rectangle) workarea
        touchManagedPtr monitor
        return workarea'

    #if ENABLE_OVERLOADING
    data MonitorGetWorkareaMethodInfo
    instance (signature ~ (m (Gdk.Rectangle.Rectangle)), MonadIO m, IsMonitor a) => O.MethodInfo MonitorGetWorkareaMethodInfo a signature where
        overloadedMethod _ = monitorGetWorkarea

    #endif

    -- method Monitor::is_primary
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkMonitor", 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_monitor_is_primary" gdk_monitor_is_primary ::
        Ptr Monitor ->                          -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
        IO CInt

    {- |
    Gets whether this monitor should be considered primary
    (see 'GI.Gdk.Objects.Display.displayGetPrimaryMonitor').

    /Since: 3.22/
    -}
    monitorIsPrimary ::
        (B.CallStack.HasCallStack, MonadIO m, IsMonitor a) =>
        a
        {- ^ /@monitor@/: a 'GI.Gdk.Objects.Monitor.Monitor' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@monitor@/ is primary -}
    monitorIsPrimary monitor = liftIO $ do
        monitor' <- unsafeManagedPtrCastPtr monitor
        result <- gdk_monitor_is_primary monitor'
        let result' = (/= 0) result
        touchManagedPtr monitor
        return result'

    #if ENABLE_OVERLOADING
    data MonitorIsPrimaryMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsMonitor a) => O.MethodInfo MonitorIsPrimaryMethodInfo a signature where
        overloadedMethod _ = monitorIsPrimary

    #endif