    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- t'GI.Gdk.Objects.GLContext.GLContext' is an object representing the platform-specific
    -- OpenGL drawing context.
    --
    -- @/GdkGLContexts/@ are created for a t'GI.Gdk.Objects.Window.Window' using
    -- 'GI.Gdk.Objects.Window.windowCreateGlContext', and the context will match
    -- the t'GI.Gdk.Objects.Visual.Visual' of the window.
    --
    -- A t'GI.Gdk.Objects.GLContext.GLContext' is not tied to any particular normal framebuffer.
    -- For instance, it cannot draw to the t'GI.Gdk.Objects.Window.Window' back buffer. The GDK
    -- repaint system is in full control of the painting to that. Instead,
    -- you can create render buffers or textures and use 'GI.Gdk.Functions.cairoDrawFromGl'
    -- in the draw function of your widget to draw them. Then GDK will handle
    -- the integration of your rendering with that of other widgets.
    --
    -- Support for t'GI.Gdk.Objects.GLContext.GLContext' is platform-specific, context creation
    -- can fail, returning 'P.Nothing' context.
    --
    -- A t'GI.Gdk.Objects.GLContext.GLContext' has to be made \"current\" in order to start using
    -- it, otherwise any OpenGL call will be ignored.
    --
    -- == Creating a new OpenGL context
    --
    -- In order to create a new t'GI.Gdk.Objects.GLContext.GLContext' instance you need a
    -- t'GI.Gdk.Objects.Window.Window', which you typically get during the realize call
    -- of a widget.
    --
    -- A t'GI.Gdk.Objects.GLContext.GLContext' is not realized until either 'GI.Gdk.Objects.GLContext.gLContextMakeCurrent',
    -- or until it is realized using 'GI.Gdk.Objects.GLContext.gLContextRealize'. It is possible to
    -- specify details of the GL context like the OpenGL version to be used, or
    -- whether the GL context should have extra state validation enabled after
    -- calling 'GI.Gdk.Objects.Window.windowCreateGlContext' by calling 'GI.Gdk.Objects.GLContext.gLContextRealize'.
    -- If the realization fails you have the option to change the settings of the
    -- t'GI.Gdk.Objects.GLContext.GLContext' and try again.
    --
    -- == Using a GdkGLContext
    --
    -- You will need to make the t'GI.Gdk.Objects.GLContext.GLContext' the current context
    -- before issuing OpenGL calls; the system sends OpenGL commands to
    -- whichever context is current. It is possible to have multiple
    -- contexts, so you always need to ensure that the one which you
    -- want to draw with is the current one before issuing commands:
    --
    --
    -- === /C code/
    -- >
    -- >  gdk_gl_context_make_current (context);
    --
    --
    -- You can now perform your drawing using OpenGL commands.
    --
    -- You can check which t'GI.Gdk.Objects.GLContext.GLContext' is the current one by using
    -- 'GI.Gdk.Objects.GLContext.gLContextGetCurrent'; you can also unset any t'GI.Gdk.Objects.GLContext.GLContext'
    -- that is currently set by calling 'GI.Gdk.Objects.GLContext.gLContextClearCurrent'.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gdk.Objects.GLContext
        (

    -- * Exported types
        GLContext(..)                           ,
        IsGLContext                             ,
        toGLContext                             ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveGLContextMethod                  ,
    #endif

    -- ** clearCurrent #method:clearCurrent#

        gLContextClearCurrent                   ,

    -- ** getCurrent #method:getCurrent#

        gLContextGetCurrent                     ,

    -- ** getDebugEnabled #method:getDebugEnabled#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetDebugEnabledMethodInfo      ,
    #endif
        gLContextGetDebugEnabled                ,

    -- ** getDisplay #method:getDisplay#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetDisplayMethodInfo           ,
    #endif
        gLContextGetDisplay                     ,

    -- ** getForwardCompatible #method:getForwardCompatible#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetForwardCompatibleMethodInfo ,
    #endif
        gLContextGetForwardCompatible           ,

    -- ** getRequiredVersion #method:getRequiredVersion#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetRequiredVersionMethodInfo   ,
    #endif
        gLContextGetRequiredVersion             ,

    -- ** getSharedContext #method:getSharedContext#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetSharedContextMethodInfo     ,
    #endif
        gLContextGetSharedContext               ,

    -- ** getUseEs #method:getUseEs#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetUseEsMethodInfo             ,
    #endif
        gLContextGetUseEs                       ,

    -- ** getVersion #method:getVersion#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetVersionMethodInfo           ,
    #endif
        gLContextGetVersion                     ,

    -- ** getWindow #method:getWindow#

    #if defined(ENABLE_OVERLOADING)
        GLContextGetWindowMethodInfo            ,
    #endif
        gLContextGetWindow                      ,

    -- ** isLegacy #method:isLegacy#

    #if defined(ENABLE_OVERLOADING)
        GLContextIsLegacyMethodInfo             ,
    #endif
        gLContextIsLegacy                       ,

    -- ** makeCurrent #method:makeCurrent#

    #if defined(ENABLE_OVERLOADING)
        GLContextMakeCurrentMethodInfo          ,
    #endif
        gLContextMakeCurrent                    ,

    -- ** realize #method:realize#

    #if defined(ENABLE_OVERLOADING)
        GLContextRealizeMethodInfo              ,
    #endif
        gLContextRealize                        ,

    -- ** setDebugEnabled #method:setDebugEnabled#

    #if defined(ENABLE_OVERLOADING)
        GLContextSetDebugEnabledMethodInfo      ,
    #endif
        gLContextSetDebugEnabled                ,

    -- ** setForwardCompatible #method:setForwardCompatible#

    #if defined(ENABLE_OVERLOADING)
        GLContextSetForwardCompatibleMethodInfo ,
    #endif
        gLContextSetForwardCompatible           ,

    -- ** setRequiredVersion #method:setRequiredVersion#

    #if defined(ENABLE_OVERLOADING)
        GLContextSetRequiredVersionMethodInfo   ,
    #endif
        gLContextSetRequiredVersion             ,

    -- ** setUseEs #method:setUseEs#

    #if defined(ENABLE_OVERLOADING)
        GLContextSetUseEsMethodInfo             ,
    #endif
        gLContextSetUseEs                       ,

     -- * Properties
    -- ** display #attr:display#
    -- | The t'GI.Gdk.Objects.Display.Display' used to create the t'GI.Gdk.Objects.GLContext.GLContext'.
    --
    -- /Since: 3.16/

    #if defined(ENABLE_OVERLOADING)
        GLContextDisplayPropertyInfo            ,
    #endif
        constructGLContextDisplay               ,
    #if defined(ENABLE_OVERLOADING)
        gLContextDisplay                        ,
    #endif
        getGLContextDisplay                     ,

    -- ** sharedContext #attr:sharedContext#
    -- | The t'GI.Gdk.Objects.GLContext.GLContext' that this context is sharing data with, or 'P.Nothing'
    --
    -- /Since: 3.16/

    #if defined(ENABLE_OVERLOADING)
        GLContextSharedContextPropertyInfo      ,
    #endif
        constructGLContextSharedContext         ,
    #if defined(ENABLE_OVERLOADING)
        gLContextSharedContext                  ,
    #endif
        getGLContextSharedContext               ,

    -- ** window #attr:window#
    -- | The t'GI.Gdk.Objects.Window.Window' the gl context is bound to.
    --
    -- /Since: 3.16/

    #if defined(ENABLE_OVERLOADING)
        GLContextWindowPropertyInfo             ,
    #endif
        constructGLContextWindow                ,
    #if defined(ENABLE_OVERLOADING)
        gLContextWindow                         ,
    #endif
        getGLContextWindow                      ,

        ) 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.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    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.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    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 GHC.OverloadedLabels as OL

    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.Window as Gdk.Window

    -- | Memory-managed wrapper type.
    newtype GLContext = GLContext (SP.ManagedPtr GLContext)
        deriving (GLContext -> GLContext -> Bool
    (GLContext -> GLContext -> Bool)
    -> (GLContext -> GLContext -> Bool) -> Eq GLContext
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: GLContext -> GLContext -> Bool
    $c/= :: GLContext -> GLContext -> Bool
    == :: GLContext -> GLContext -> Bool
    $c== :: GLContext -> GLContext -> Bool
    Eq)

    instance SP.ManagedPtrNewtype GLContext where
        toManagedPtr :: GLContext -> ManagedPtr GLContext
    toManagedPtr (GLContext p :: ManagedPtr GLContext
    p) = ManagedPtr GLContext
    p

    foreign import ccall "gdk_gl_context_get_type"
        c_gdk_gl_context_get_type :: IO B.Types.GType

    instance B.Types.TypedObject GLContext where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_gl_context_get_type

    instance B.Types.GObject GLContext

    -- | Convert 'GLContext' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue GLContext where
        toGValue :: GLContext -> IO GValue
    toGValue o :: GLContext
    o = do
            GType
    gtype <- IO GType
    c_gdk_gl_context_get_type
            GLContext -> (Ptr GLContext -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr GLContext
    o (GType
    -> (GValue -> Ptr GLContext -> IO ()) -> Ptr GLContext -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr GLContext -> IO ()
    forall a. GObject a => GValue -> Ptr a -> IO ()
    B.GValue.set_object)

        fromGValue :: GValue -> IO GLContext
    fromGValue gv :: GValue
    gv = do
            Ptr GLContext
    ptr <- GValue -> IO (Ptr GLContext)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr GLContext)
            (ManagedPtr GLContext -> GLContext)
    -> Ptr GLContext -> IO GLContext
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr GLContext -> GLContext
    GLContext Ptr GLContext
    ptr

    -- | Type class for types which can be safely cast to `GLContext`, for instance with `toGLContext`.
    class (SP.GObject o, O.IsDescendantOf GLContext o) => IsGLContext o
    instance (SP.GObject o, O.IsDescendantOf GLContext o) => IsGLContext o

    instance O.HasParentTypes GLContext
    type instance O.ParentTypes GLContext = '[GObject.Object.Object]

    -- | Cast to `GLContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toGLContext :: (MonadIO m, IsGLContext o) => o -> m GLContext
    toGLContext :: o -> m GLContext
    toGLContext = IO GLContext -> m GLContext
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLContext -> m GLContext)
    -> (o -> IO GLContext) -> o -> m GLContext
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr GLContext -> GLContext) -> o -> IO GLContext
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    unsafeCastTo ManagedPtr GLContext -> GLContext
    GLContext

    #if defined(ENABLE_OVERLOADING)
    type family ResolveGLContextMethod (t :: Symbol) (o :: *) :: * where
        ResolveGLContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveGLContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveGLContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveGLContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveGLContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveGLContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveGLContextMethod "isLegacy" o = GLContextIsLegacyMethodInfo
        ResolveGLContextMethod "makeCurrent" o = GLContextMakeCurrentMethodInfo
        ResolveGLContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveGLContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveGLContextMethod "realize" o = GLContextRealizeMethodInfo
        ResolveGLContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveGLContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveGLContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveGLContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveGLContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveGLContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveGLContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveGLContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveGLContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveGLContextMethod "getDebugEnabled" o = GLContextGetDebugEnabledMethodInfo
        ResolveGLContextMethod "getDisplay" o = GLContextGetDisplayMethodInfo
        ResolveGLContextMethod "getForwardCompatible" o = GLContextGetForwardCompatibleMethodInfo
        ResolveGLContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveGLContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveGLContextMethod "getRequiredVersion" o = GLContextGetRequiredVersionMethodInfo
        ResolveGLContextMethod "getSharedContext" o = GLContextGetSharedContextMethodInfo
        ResolveGLContextMethod "getUseEs" o = GLContextGetUseEsMethodInfo
        ResolveGLContextMethod "getVersion" o = GLContextGetVersionMethodInfo
        ResolveGLContextMethod "getWindow" o = GLContextGetWindowMethodInfo
        ResolveGLContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveGLContextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveGLContextMethod "setDebugEnabled" o = GLContextSetDebugEnabledMethodInfo
        ResolveGLContextMethod "setForwardCompatible" o = GLContextSetForwardCompatibleMethodInfo
        ResolveGLContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveGLContextMethod "setRequiredVersion" o = GLContextSetRequiredVersionMethodInfo
        ResolveGLContextMethod "setUseEs" o = GLContextSetUseEsMethodInfo
        ResolveGLContextMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveGLContextMethod t GLContext, O.MethodInfo info GLContext p) => OL.IsLabel t (GLContext -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #endif

    -- VVV Prop "display"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Display"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just True,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' gLContext #display
    -- @
    getGLContextDisplay :: (MonadIO m, IsGLContext o) => o -> m (Maybe Gdk.Display.Display)
    getGLContextDisplay :: o -> m (Maybe Display)
    getGLContextDisplay obj :: o
    obj = IO (Maybe Display) -> m (Maybe Display)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Display) -> m (Maybe Display))
    -> IO (Maybe Display) -> m (Maybe Display)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String -> (ManagedPtr Display -> Display) -> IO (Maybe Display)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj "display" ManagedPtr Display -> 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`.
    constructGLContextDisplay :: (IsGLContext o, MIO.MonadIO m, Gdk.Display.IsDisplay a) => a -> m (GValueConstruct o)
    constructGLContextDisplay :: a -> m (GValueConstruct o)
    constructGLContextDisplay val :: a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject "display" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    #if defined(ENABLE_OVERLOADING)
    data GLContextDisplayPropertyInfo
    instance AttrInfo GLContextDisplayPropertyInfo where
        type AttrAllowedOps GLContextDisplayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint GLContextDisplayPropertyInfo = IsGLContext
        type AttrSetTypeConstraint GLContextDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferTypeConstraint GLContextDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferType GLContextDisplayPropertyInfo = Gdk.Display.Display
        type AttrGetType GLContextDisplayPropertyInfo = (Maybe Gdk.Display.Display)
        type AttrLabel GLContextDisplayPropertyInfo = "display"
        type AttrOrigin GLContextDisplayPropertyInfo = GLContext
        attrGet = getGLContextDisplay
        attrSet = undefined
        attrTransfer _ v = do
            unsafeCastTo Gdk.Display.Display v
        attrConstruct = constructGLContextDisplay
        attrClear = undefined
    #endif

    -- VVV Prop "shared-context"
       -- Type: TInterface (Name {namespace = "Gdk", name = "GLContext"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just True,Nothing)

    -- | Get the value of the “@shared-context@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' gLContext #sharedContext
    -- @
    getGLContextSharedContext :: (MonadIO m, IsGLContext o) => o -> m (Maybe GLContext)
    getGLContextSharedContext :: o -> m (Maybe GLContext)
    getGLContextSharedContext obj :: o
    obj = IO (Maybe GLContext) -> m (Maybe GLContext)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GLContext) -> m (Maybe GLContext))
    -> IO (Maybe GLContext) -> m (Maybe GLContext)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr GLContext -> GLContext)
    -> IO (Maybe GLContext)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj "shared-context" ManagedPtr GLContext -> GLContext
    GLContext

    -- | Construct a `GValueConstruct` with valid value for the “@shared-context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructGLContextSharedContext :: (IsGLContext o, MIO.MonadIO m, IsGLContext a) => a -> m (GValueConstruct o)
    constructGLContextSharedContext :: a -> m (GValueConstruct o)
    constructGLContextSharedContext val :: a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject "shared-context" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    #if defined(ENABLE_OVERLOADING)
    data GLContextSharedContextPropertyInfo
    instance AttrInfo GLContextSharedContextPropertyInfo where
        type AttrAllowedOps GLContextSharedContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint GLContextSharedContextPropertyInfo = IsGLContext
        type AttrSetTypeConstraint GLContextSharedContextPropertyInfo = IsGLContext
        type AttrTransferTypeConstraint GLContextSharedContextPropertyInfo = IsGLContext
        type AttrTransferType GLContextSharedContextPropertyInfo = GLContext
        type AttrGetType GLContextSharedContextPropertyInfo = (Maybe GLContext)
        type AttrLabel GLContextSharedContextPropertyInfo = "shared-context"
        type AttrOrigin GLContextSharedContextPropertyInfo = GLContext
        attrGet = getGLContextSharedContext
        attrSet = undefined
        attrTransfer _ v = do
            unsafeCastTo GLContext v
        attrConstruct = constructGLContextSharedContext
        attrClear = undefined
    #endif

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

    -- | Get the value of the “@window@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' gLContext #window
    -- @
    getGLContextWindow :: (MonadIO m, IsGLContext o) => o -> m (Maybe Gdk.Window.Window)
    getGLContextWindow :: o -> m (Maybe Window)
    getGLContextWindow obj :: o
    obj = IO (Maybe Window) -> m (Maybe Window)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Window) -> m (Maybe Window))
    -> IO (Maybe Window) -> m (Maybe Window)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Window -> Window) -> IO (Maybe Window)
    forall a b.
    (GObject a, GObject b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyObject o
    obj "window" ManagedPtr Window -> Window
    Gdk.Window.Window

    -- | Construct a `GValueConstruct` with valid value for the “@window@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructGLContextWindow :: (IsGLContext o, MIO.MonadIO m, Gdk.Window.IsWindow a) => a -> m (GValueConstruct o)
    constructGLContextWindow :: a -> m (GValueConstruct o)
    constructGLContextWindow val :: a
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe a -> IO (GValueConstruct o)
    forall a o.
    GObject a =>
    String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyObject "window" (a -> Maybe a
    forall a. a -> Maybe a
    P.Just a
    val)

    #if defined(ENABLE_OVERLOADING)
    data GLContextWindowPropertyInfo
    instance AttrInfo GLContextWindowPropertyInfo where
        type AttrAllowedOps GLContextWindowPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint GLContextWindowPropertyInfo = IsGLContext
        type AttrSetTypeConstraint GLContextWindowPropertyInfo = Gdk.Window.IsWindow
        type AttrTransferTypeConstraint GLContextWindowPropertyInfo = Gdk.Window.IsWindow
        type AttrTransferType GLContextWindowPropertyInfo = Gdk.Window.Window
        type AttrGetType GLContextWindowPropertyInfo = (Maybe Gdk.Window.Window)
        type AttrLabel GLContextWindowPropertyInfo = "window"
        type AttrOrigin GLContextWindowPropertyInfo = GLContext
        attrGet = getGLContextWindow
        attrSet = undefined
        attrTransfer _ v = do
            unsafeCastTo Gdk.Window.Window v
        attrConstruct = constructGLContextWindow
        attrClear = undefined
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList GLContext
    type instance O.AttributeList GLContext = GLContextAttributeList
    type GLContextAttributeList = ('[ '("display", GLContextDisplayPropertyInfo), '("sharedContext", GLContextSharedContextPropertyInfo), '("window", GLContextWindowPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    gLContextDisplay :: AttrLabelProxy "display"
    gLContextDisplay = AttrLabelProxy

    gLContextSharedContext :: AttrLabelProxy "sharedContext"
    gLContextSharedContext = AttrLabelProxy

    gLContextWindow :: AttrLabelProxy "window"
    gLContextWindow = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList GLContext = GLContextSignalList
    type GLContextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method GLContext::get_debug_enabled
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , 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_gl_context_get_debug_enabled" gdk_gl_context_get_debug_enabled ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        IO CInt

    -- | Retrieves the value set using 'GI.Gdk.Objects.GLContext.gLContextSetDebugEnabled'.
    --
    -- /Since: 3.16/
    gLContextGetDebugEnabled ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if debugging is enabled
    gLContextGetDebugEnabled :: a -> m Bool
    gLContextGetDebugEnabled context :: a
    context = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CInt
    result <- Ptr GLContext -> IO CInt
    gdk_gl_context_get_debug_enabled Ptr GLContext
    context'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetDebugEnabledMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetDebugEnabledMethodInfo a signature where
        overloadedMethod = gLContextGetDebugEnabled

    #endif

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

    -- | Retrieves the t'GI.Gdk.Objects.Display.Display' the /@context@/ is created for
    --
    -- /Since: 3.16/
    gLContextGetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m (Maybe Gdk.Display.Display)
        -- ^ __Returns:__ a t'GI.Gdk.Objects.Display.Display' or 'P.Nothing'
    gLContextGetDisplay :: a -> m (Maybe Display)
    gLContextGetDisplay context :: a
    context = IO (Maybe Display) -> m (Maybe Display)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Display) -> m (Maybe Display))
    -> IO (Maybe Display) -> m (Maybe Display)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Display
    result <- Ptr GLContext -> IO (Ptr Display)
    gdk_gl_context_get_display Ptr GLContext
    context'
        Maybe Display
    maybeResult <- Ptr Display -> (Ptr Display -> IO Display) -> IO (Maybe Display)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Display
    result ((Ptr Display -> IO Display) -> IO (Maybe Display))
    -> (Ptr Display -> IO Display) -> IO (Maybe Display)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Display
    result' -> do
            Display
    result'' <- ((ManagedPtr Display -> Display) -> Ptr Display -> IO Display
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Display -> Display
    Gdk.Display.Display) Ptr Display
    result'
            Display -> IO Display
    forall (m :: * -> *) a. Monad m => a -> m a
    return Display
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe Display -> IO (Maybe Display)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Display
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetDisplayMethodInfo
    instance (signature ~ (m (Maybe Gdk.Display.Display)), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetDisplayMethodInfo a signature where
        overloadedMethod = gLContextGetDisplay

    #endif

    -- method GLContext::get_forward_compatible
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , 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_gl_context_get_forward_compatible" gdk_gl_context_get_forward_compatible ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        IO CInt

    -- | Retrieves the value set using 'GI.Gdk.Objects.GLContext.gLContextSetForwardCompatible'.
    --
    -- /Since: 3.16/
    gLContextGetForwardCompatible ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the context should be forward compatible
    gLContextGetForwardCompatible :: a -> m Bool
    gLContextGetForwardCompatible context :: a
    context = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CInt
    result <- Ptr GLContext -> IO CInt
    gdk_gl_context_get_forward_compatible Ptr GLContext
    context'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetForwardCompatibleMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetForwardCompatibleMethodInfo a signature where
        overloadedMethod = gLContextGetForwardCompatible

    #endif

    -- method GLContext::get_required_version
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "major"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the major version to request"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "minor"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the minor version to request"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_gl_context_get_required_version" gdk_gl_context_get_required_version ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        Ptr Int32 ->                            -- major : TBasicType TInt
        Ptr Int32 ->                            -- minor : TBasicType TInt
        IO ()

    -- | Retrieves the major and minor version requested by calling
    -- 'GI.Gdk.Objects.GLContext.gLContextSetRequiredVersion'.
    --
    -- /Since: 3.16/
    gLContextGetRequiredVersion ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m ((Int32, Int32))
    gLContextGetRequiredVersion :: a -> m (Int32, Int32)
    gLContextGetRequiredVersion context :: a
    context = IO (Int32, Int32) -> m (Int32, Int32)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int32, Int32) -> m (Int32, Int32))
    -> IO (Int32, Int32) -> m (Int32, Int32)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Int32
    major <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr Int32
    minor <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr GLContext -> Ptr Int32 -> Ptr Int32 -> IO ()
    gdk_gl_context_get_required_version Ptr GLContext
    context' Ptr Int32
    major Ptr Int32
    minor
        Int32
    major' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    major
        Int32
    minor' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    minor
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    major
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    minor
        (Int32, Int32) -> IO (Int32, Int32)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32
    major', Int32
    minor')

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetRequiredVersionMethodInfo
    instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetRequiredVersionMethodInfo a signature where
        overloadedMethod = gLContextGetRequiredVersion

    #endif

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

    foreign import ccall "gdk_gl_context_get_shared_context" gdk_gl_context_get_shared_context ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        IO (Ptr GLContext)

    -- | Retrieves the t'GI.Gdk.Objects.GLContext.GLContext' that this /@context@/ share data with.
    --
    -- /Since: 3.16/
    gLContextGetSharedContext ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m (Maybe GLContext)
        -- ^ __Returns:__ a t'GI.Gdk.Objects.GLContext.GLContext' or 'P.Nothing'
    gLContextGetSharedContext :: a -> m (Maybe GLContext)
    gLContextGetSharedContext context :: a
    context = IO (Maybe GLContext) -> m (Maybe GLContext)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GLContext) -> m (Maybe GLContext))
    -> IO (Maybe GLContext) -> m (Maybe GLContext)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr GLContext
    result <- Ptr GLContext -> IO (Ptr GLContext)
    gdk_gl_context_get_shared_context Ptr GLContext
    context'
        Maybe GLContext
    maybeResult <- Ptr GLContext
    -> (Ptr GLContext -> IO GLContext) -> IO (Maybe GLContext)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr GLContext
    result ((Ptr GLContext -> IO GLContext) -> IO (Maybe GLContext))
    -> (Ptr GLContext -> IO GLContext) -> IO (Maybe GLContext)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr GLContext
    result' -> do
            GLContext
    result'' <- ((ManagedPtr GLContext -> GLContext)
    -> Ptr GLContext -> IO GLContext
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr GLContext -> GLContext
    GLContext) Ptr GLContext
    result'
            GLContext -> IO GLContext
    forall (m :: * -> *) a. Monad m => a -> m a
    return GLContext
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe GLContext -> IO (Maybe GLContext)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GLContext
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetSharedContextMethodInfo
    instance (signature ~ (m (Maybe GLContext)), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetSharedContextMethodInfo a signature where
        overloadedMethod = gLContextGetSharedContext

    #endif

    -- method GLContext::get_use_es
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , 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_gl_context_get_use_es" gdk_gl_context_get_use_es ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        IO CInt

    -- | Checks whether the /@context@/ is using an OpenGL or OpenGL ES profile.
    --
    -- /Since: 3.22/
    gLContextGetUseEs ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the t'GI.Gdk.Objects.GLContext.GLContext' is using an OpenGL ES profile
    gLContextGetUseEs :: a -> m Bool
    gLContextGetUseEs context :: a
    context = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CInt
    result <- Ptr GLContext -> IO CInt
    gdk_gl_context_get_use_es Ptr GLContext
    context'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetUseEsMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetUseEsMethodInfo a signature where
        overloadedMethod = gLContextGetUseEs

    #endif

    -- method GLContext::get_version
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "major"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the major version"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "minor"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the minor version"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_gl_context_get_version" gdk_gl_context_get_version ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        Ptr Int32 ->                            -- major : TBasicType TInt
        Ptr Int32 ->                            -- minor : TBasicType TInt
        IO ()

    -- | Retrieves the OpenGL version of the /@context@/.
    --
    -- The /@context@/ must be realized prior to calling this function.
    --
    -- /Since: 3.16/
    gLContextGetVersion ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m ((Int32, Int32))
    gLContextGetVersion :: a -> m (Int32, Int32)
    gLContextGetVersion context :: a
    context = IO (Int32, Int32) -> m (Int32, Int32)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int32, Int32) -> m (Int32, Int32))
    -> IO (Int32, Int32) -> m (Int32, Int32)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Int32
    major <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr Int32
    minor <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr GLContext -> Ptr Int32 -> Ptr Int32 -> IO ()
    gdk_gl_context_get_version Ptr GLContext
    context' Ptr Int32
    major Ptr Int32
    minor
        Int32
    major' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    major
        Int32
    minor' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    minor
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    major
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    minor
        (Int32, Int32) -> IO (Int32, Int32)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32
    major', Int32
    minor')

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetVersionMethodInfo
    instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetVersionMethodInfo a signature where
        overloadedMethod = gLContextGetVersion

    #endif

    -- method GLContext::get_window
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , 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_gl_context_get_window" gdk_gl_context_get_window ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        IO (Ptr Gdk.Window.Window)

    -- | Retrieves the t'GI.Gdk.Objects.Window.Window' used by the /@context@/.
    --
    -- /Since: 3.16/
    gLContextGetWindow ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m (Maybe Gdk.Window.Window)
        -- ^ __Returns:__ a t'GI.Gdk.Objects.Window.Window' or 'P.Nothing'
    gLContextGetWindow :: a -> m (Maybe Window)
    gLContextGetWindow context :: a
    context = IO (Maybe Window) -> m (Maybe Window)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Window) -> m (Maybe Window))
    -> IO (Maybe Window) -> m (Maybe Window)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Window
    result <- Ptr GLContext -> IO (Ptr Window)
    gdk_gl_context_get_window Ptr GLContext
    context'
        Maybe Window
    maybeResult <- Ptr Window -> (Ptr Window -> IO Window) -> IO (Maybe Window)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Window
    result ((Ptr Window -> IO Window) -> IO (Maybe Window))
    -> (Ptr Window -> IO Window) -> IO (Maybe Window)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Window
    result' -> do
            Window
    result'' <- ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Window -> Window
    Gdk.Window.Window) Ptr Window
    result'
            Window -> IO Window
    forall (m :: * -> *) a. Monad m => a -> m a
    return Window
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe Window -> IO (Maybe Window)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Window
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data GLContextGetWindowMethodInfo
    instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsGLContext a) => O.MethodInfo GLContextGetWindowMethodInfo a signature where
        overloadedMethod = gLContextGetWindow

    #endif

    -- method GLContext::is_legacy
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , 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_gl_context_is_legacy" gdk_gl_context_is_legacy ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        IO CInt

    -- | Whether the t'GI.Gdk.Objects.GLContext.GLContext' is in legacy mode or not.
    --
    -- The t'GI.Gdk.Objects.GLContext.GLContext' must be realized before calling this function.
    --
    -- When realizing a GL context, GDK will try to use the OpenGL 3.2 core
    -- profile; this profile removes all the OpenGL API that was deprecated
    -- prior to the 3.2 version of the specification. If the realization is
    -- successful, this function will return 'P.False'.
    --
    -- If the underlying OpenGL implementation does not support core profiles,
    -- GDK will fall back to a pre-3.2 compatibility profile, and this function
    -- will return 'P.True'.
    --
    -- You can use the value returned by this function to decide which kind
    -- of OpenGL API to use, or whether to do extension discovery, or what
    -- kind of shader programs to load.
    --
    -- /Since: 3.20/
    gLContextIsLegacy ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the GL context is in legacy mode
    gLContextIsLegacy :: a -> m Bool
    gLContextIsLegacy context :: a
    context = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CInt
    result <- Ptr GLContext -> IO CInt
    gdk_gl_context_is_legacy Ptr GLContext
    context'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data GLContextIsLegacyMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsGLContext a) => O.MethodInfo GLContextIsLegacyMethodInfo a signature where
        overloadedMethod = gLContextIsLegacy

    #endif

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

    foreign import ccall "gdk_gl_context_make_current" gdk_gl_context_make_current ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        IO ()

    -- | Makes the /@context@/ the current one.
    --
    -- /Since: 3.16/
    gLContextMakeCurrent ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m ()
    gLContextMakeCurrent :: a -> m ()
    gLContextMakeCurrent context :: a
    context = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr GLContext -> IO ()
    gdk_gl_context_make_current Ptr GLContext
    context'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data GLContextMakeCurrentMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsGLContext a) => O.MethodInfo GLContextMakeCurrentMethodInfo a signature where
        overloadedMethod = gLContextMakeCurrent

    #endif

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

    foreign import ccall "gdk_gl_context_realize" gdk_gl_context_realize ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Realizes the given t'GI.Gdk.Objects.GLContext.GLContext'.
    --
    -- It is safe to call this function on a realized t'GI.Gdk.Objects.GLContext.GLContext'.
    --
    -- /Since: 3.16/
    gLContextRealize ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    gLContextRealize :: a -> m ()
    gLContextRealize context :: a
    context = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        IO () -> IO () -> IO ()
    forall a b. IO a -> IO b -> IO a
    onException (do
            CInt
    _ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
    -> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ Ptr GLContext -> Ptr (Ptr GError) -> IO CInt
    gdk_gl_context_realize Ptr GLContext
    context'
            a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
            () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         ) (do
            () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data GLContextRealizeMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsGLContext a) => O.MethodInfo GLContextRealizeMethodInfo a signature where
        overloadedMethod = gLContextRealize

    #endif

    -- method GLContext::set_debug_enabled
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "enabled"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to enable debugging in the context"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_gl_context_set_debug_enabled" gdk_gl_context_set_debug_enabled ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        CInt ->                                 -- enabled : TBasicType TBoolean
        IO ()

    -- | Sets whether the t'GI.Gdk.Objects.GLContext.GLContext' should perform extra validations and
    -- run time checking. This is useful during development, but has
    -- additional overhead.
    --
    -- The t'GI.Gdk.Objects.GLContext.GLContext' must not be realized or made current prior to
    -- calling this function.
    --
    -- /Since: 3.16/
    gLContextSetDebugEnabled ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> Bool
        -- ^ /@enabled@/: whether to enable debugging in the context
        -> m ()
    gLContextSetDebugEnabled :: a -> Bool -> m ()
    gLContextSetDebugEnabled context :: a
    context enabled :: Bool
    enabled = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        let enabled' :: CInt
    enabled' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum) Bool
    enabled
        Ptr GLContext -> CInt -> IO ()
    gdk_gl_context_set_debug_enabled Ptr GLContext
    context' CInt
    enabled'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data GLContextSetDebugEnabledMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsGLContext a) => O.MethodInfo GLContextSetDebugEnabledMethodInfo a signature where
        overloadedMethod = gLContextSetDebugEnabled

    #endif

    -- method GLContext::set_forward_compatible
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "compatible"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "whether the context should be forward compatible"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_gl_context_set_forward_compatible" gdk_gl_context_set_forward_compatible ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        CInt ->                                 -- compatible : TBasicType TBoolean
        IO ()

    -- | Sets whether the t'GI.Gdk.Objects.GLContext.GLContext' should be forward compatible.
    --
    -- Forward compatibile contexts must not support OpenGL functionality that
    -- has been marked as deprecated in the requested version; non-forward
    -- compatible contexts, on the other hand, must support both deprecated and
    -- non deprecated functionality.
    --
    -- The t'GI.Gdk.Objects.GLContext.GLContext' must not be realized or made current prior to calling
    -- this function.
    --
    -- /Since: 3.16/
    gLContextSetForwardCompatible ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> Bool
        -- ^ /@compatible@/: whether the context should be forward compatible
        -> m ()
    gLContextSetForwardCompatible :: a -> Bool -> m ()
    gLContextSetForwardCompatible context :: a
    context compatible :: Bool
    compatible = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        let compatible' :: CInt
    compatible' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum) Bool
    compatible
        Ptr GLContext -> CInt -> IO ()
    gdk_gl_context_set_forward_compatible Ptr GLContext
    context' CInt
    compatible'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data GLContextSetForwardCompatibleMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsGLContext a) => O.MethodInfo GLContextSetForwardCompatibleMethodInfo a signature where
        overloadedMethod = gLContextSetForwardCompatible

    #endif

    -- method GLContext::set_required_version
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "major"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the major version to request"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "minor"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the minor version to request"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_gl_context_set_required_version" gdk_gl_context_set_required_version ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        Int32 ->                                -- major : TBasicType TInt
        Int32 ->                                -- minor : TBasicType TInt
        IO ()

    -- | Sets the major and minor version of OpenGL to request.
    --
    -- Setting /@major@/ and /@minor@/ to zero will use the default values.
    --
    -- The t'GI.Gdk.Objects.GLContext.GLContext' must not be realized or made current prior to calling
    -- this function.
    --
    -- /Since: 3.16/
    gLContextSetRequiredVersion ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext'
        -> Int32
        -- ^ /@major@/: the major version to request
        -> Int32
        -- ^ /@minor@/: the minor version to request
        -> m ()
    gLContextSetRequiredVersion :: a -> Int32 -> Int32 -> m ()
    gLContextSetRequiredVersion context :: a
    context major :: Int32
    major minor :: Int32
    minor = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr GLContext -> Int32 -> Int32 -> IO ()
    gdk_gl_context_set_required_version Ptr GLContext
    context' Int32
    major Int32
    minor
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data GLContextSetRequiredVersionMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsGLContext a) => O.MethodInfo GLContextSetRequiredVersionMethodInfo a signature where
        overloadedMethod = gLContextSetRequiredVersion

    #endif

    -- method GLContext::set_use_es
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "GLContext" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkGLContext:" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "use_es"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "whether the context should use OpenGL ES instead of OpenGL,\n  or -1 to allow auto-detection"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_gl_context_set_use_es" gdk_gl_context_set_use_es ::
        Ptr GLContext ->                        -- context : TInterface (Name {namespace = "Gdk", name = "GLContext"})
        Int32 ->                                -- use_es : TBasicType TInt
        IO ()

    -- | Requests that GDK create a OpenGL ES context instead of an OpenGL one,
    -- if the platform and windowing system allows it.
    --
    -- The /@context@/ must not have been realized.
    --
    -- By default, GDK will attempt to automatically detect whether the
    -- underlying GL implementation is OpenGL or OpenGL ES once the /@context@/
    -- is realized.
    --
    -- You should check the return value of 'GI.Gdk.Objects.GLContext.gLContextGetUseEs' after
    -- calling 'GI.Gdk.Objects.GLContext.gLContextRealize' to decide whether to use the OpenGL or
    -- OpenGL ES API, extensions, or shaders.
    --
    -- /Since: 3.22/
    gLContextSetUseEs ::
        (B.CallStack.HasCallStack, MonadIO m, IsGLContext a) =>
        a
        -- ^ /@context@/: a t'GI.Gdk.Objects.GLContext.GLContext':
        -> Int32
        -- ^ /@useEs@/: whether the context should use OpenGL ES instead of OpenGL,
        --   or -1 to allow auto-detection
        -> m ()
    gLContextSetUseEs :: a -> Int32 -> m ()
    gLContextSetUseEs context :: a
    context useEs :: Int32
    useEs = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    context' <- a -> IO (Ptr GLContext)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr GLContext -> Int32 -> IO ()
    gdk_gl_context_set_use_es Ptr GLContext
    context' Int32
    useEs
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data GLContextSetUseEsMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsGLContext a) => O.MethodInfo GLContextSetUseEsMethodInfo a signature where
        overloadedMethod = gLContextSetUseEs

    #endif

    -- method GLContext::clear_current
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_gl_context_clear_current" gdk_gl_context_clear_current ::
        IO ()

    -- | Clears the current t'GI.Gdk.Objects.GLContext.GLContext'.
    --
    -- Any OpenGL call after this function returns will be ignored
    -- until 'GI.Gdk.Objects.GLContext.gLContextMakeCurrent' is called.
    --
    -- /Since: 3.16/
    gLContextClearCurrent ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m ()
    gLContextClearCurrent :: m ()
    gLContextClearCurrent  = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        IO ()
    gdk_gl_context_clear_current
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "gdk_gl_context_get_current" gdk_gl_context_get_current ::
        IO (Ptr GLContext)

    -- | Retrieves the current t'GI.Gdk.Objects.GLContext.GLContext'.
    --
    -- /Since: 3.16/
    gLContextGetCurrent ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m (Maybe GLContext)
        -- ^ __Returns:__ the current t'GI.Gdk.Objects.GLContext.GLContext', or 'P.Nothing'
    gLContextGetCurrent :: m (Maybe GLContext)
    gLContextGetCurrent  = IO (Maybe GLContext) -> m (Maybe GLContext)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GLContext) -> m (Maybe GLContext))
    -> IO (Maybe GLContext) -> m (Maybe GLContext)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr GLContext
    result <- IO (Ptr GLContext)
    gdk_gl_context_get_current
        Maybe GLContext
    maybeResult <- Ptr GLContext
    -> (Ptr GLContext -> IO GLContext) -> IO (Maybe GLContext)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr GLContext
    result ((Ptr GLContext -> IO GLContext) -> IO (Maybe GLContext))
    -> (Ptr GLContext -> IO GLContext) -> IO (Maybe GLContext)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr GLContext
    result' -> do
            GLContext
    result'' <- ((ManagedPtr GLContext -> GLContext)
    -> Ptr GLContext -> IO GLContext
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr GLContext -> GLContext
    GLContext) Ptr GLContext
    result'
            GLContext -> IO GLContext
    forall (m :: * -> *) a. Monad m => a -> m a
    return GLContext
    result''
        Maybe GLContext -> IO (Maybe GLContext)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GLContext
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    #endif