    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A t'GI.Gdk.Objects.Cursor.Cursor' represents a cursor. Its contents are private.

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

    module GI.Gdk.Objects.Cursor
        (

    -- * Exported types
        Cursor(..)                              ,
        IsCursor                                ,
        toCursor                                ,

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

    #if defined(ENABLE_OVERLOADING)
        ResolveCursorMethod                     ,
    #endif

    -- ** getCursorType #method:getCursorType#

    #if defined(ENABLE_OVERLOADING)
        CursorGetCursorTypeMethodInfo           ,
    #endif
        cursorGetCursorType                     ,

    -- ** getDisplay #method:getDisplay#

    #if defined(ENABLE_OVERLOADING)
        CursorGetDisplayMethodInfo              ,
    #endif
        cursorGetDisplay                        ,

    -- ** getImage #method:getImage#

    #if defined(ENABLE_OVERLOADING)
        CursorGetImageMethodInfo                ,
    #endif
        cursorGetImage                          ,

    -- ** getSurface #method:getSurface#

    #if defined(ENABLE_OVERLOADING)
        CursorGetSurfaceMethodInfo              ,
    #endif
        cursorGetSurface                        ,

    -- ** new #method:new#

        cursorNew                               ,

    -- ** newForDisplay #method:newForDisplay#

        cursorNewForDisplay                     ,

    -- ** newFromName #method:newFromName#

        cursorNewFromName                       ,

    -- ** newFromPixbuf #method:newFromPixbuf#

        cursorNewFromPixbuf                     ,

    -- ** newFromSurface #method:newFromSurface#

        cursorNewFromSurface                    ,

    -- ** ref #method:ref#

    #if defined(ENABLE_OVERLOADING)
        CursorRefMethodInfo                     ,
    #endif
        cursorRef                               ,

    -- ** unref #method:unref#

    #if defined(ENABLE_OVERLOADING)
        CursorUnrefMethodInfo                   ,
    #endif
        cursorUnref                             ,

     -- * Properties
    -- ** cursorType #attr:cursorType#
    -- | /No description available in the introspection data./

    #if defined(ENABLE_OVERLOADING)
        CursorCursorTypePropertyInfo            ,
    #endif
        constructCursorCursorType               ,
    #if defined(ENABLE_OVERLOADING)
        cursorCursorType                        ,
    #endif
        getCursorCursorType                     ,

    -- ** display #attr:display#
    -- | /No description available in the introspection data./

    #if defined(ENABLE_OVERLOADING)
        CursorDisplayPropertyInfo               ,
    #endif
        constructCursorDisplay                  ,
    #if defined(ENABLE_OVERLOADING)
        cursorDisplay                           ,
    #endif
        getCursorDisplay                        ,

        ) 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.Cairo.Structs.Surface as Cairo.Surface
    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 qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf

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

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

    foreign import ccall "gdk_cursor_get_type"
        c_gdk_cursor_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Cursor where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_cursor_get_type

    instance B.Types.GObject Cursor

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveCursorMethod (t :: Symbol) (o :: *) :: * where
        ResolveCursorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveCursorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveCursorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveCursorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveCursorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveCursorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveCursorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveCursorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveCursorMethod "ref" o = CursorRefMethodInfo
        ResolveCursorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveCursorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveCursorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveCursorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveCursorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveCursorMethod "unref" o = CursorUnrefMethodInfo
        ResolveCursorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveCursorMethod "getCursorType" o = CursorGetCursorTypeMethodInfo
        ResolveCursorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveCursorMethod "getDisplay" o = CursorGetDisplayMethodInfo
        ResolveCursorMethod "getImage" o = CursorGetImageMethodInfo
        ResolveCursorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveCursorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveCursorMethod "getSurface" o = CursorGetSurfaceMethodInfo
        ResolveCursorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveCursorMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveCursorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveCursorMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    -- | Get the value of the “@cursor-type@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' cursor #cursorType
    -- @
    getCursorCursorType :: (MonadIO m, IsCursor o) => o -> m Gdk.Enums.CursorType
    getCursorCursorType :: o -> m CursorType
    getCursorCursorType obj :: o
    obj = IO CursorType -> m CursorType
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CursorType -> m CursorType) -> IO CursorType -> m CursorType
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO CursorType
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj "cursor-type"

    -- | Construct a `GValueConstruct` with valid value for the “@cursor-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructCursorCursorType :: (IsCursor o, MIO.MonadIO m) => Gdk.Enums.CursorType -> m (GValueConstruct o)
    constructCursorCursorType :: CursorType -> m (GValueConstruct o)
    constructCursorCursorType val :: CursorType
    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 -> CursorType -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum "cursor-type" CursorType
    val

    #if defined(ENABLE_OVERLOADING)
    data CursorCursorTypePropertyInfo
    instance AttrInfo CursorCursorTypePropertyInfo where
        type AttrAllowedOps CursorCursorTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint CursorCursorTypePropertyInfo = IsCursor
        type AttrSetTypeConstraint CursorCursorTypePropertyInfo = (~) Gdk.Enums.CursorType
        type AttrTransferTypeConstraint CursorCursorTypePropertyInfo = (~) Gdk.Enums.CursorType
        type AttrTransferType CursorCursorTypePropertyInfo = Gdk.Enums.CursorType
        type AttrGetType CursorCursorTypePropertyInfo = Gdk.Enums.CursorType
        type AttrLabel CursorCursorTypePropertyInfo = "cursor-type"
        type AttrOrigin CursorCursorTypePropertyInfo = Cursor
        attrGet = getCursorCursorType
        attrSet = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructCursorCursorType
        attrClear = undefined
    #endif

    -- 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' cursor #display
    -- @
    getCursorDisplay :: (MonadIO m, IsCursor o) => o -> m Gdk.Display.Display
    getCursorDisplay :: o -> m Display
    getCursorDisplay obj :: o
    obj = IO Display -> m Display
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Display -> m Display) -> IO Display -> m Display
    forall a b. (a -> b) -> a -> b
    $ Text -> IO (Maybe Display) -> IO Display
    forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
    checkUnexpectedNothing "getCursorDisplay" (IO (Maybe Display) -> IO Display)
    -> IO (Maybe Display) -> IO 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`.
    constructCursorDisplay :: (IsCursor o, MIO.MonadIO m, Gdk.Display.IsDisplay a) => a -> m (GValueConstruct o)
    constructCursorDisplay :: a -> m (GValueConstruct o)
    constructCursorDisplay 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 CursorDisplayPropertyInfo
    instance AttrInfo CursorDisplayPropertyInfo where
        type AttrAllowedOps CursorDisplayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint CursorDisplayPropertyInfo = IsCursor
        type AttrSetTypeConstraint CursorDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferTypeConstraint CursorDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferType CursorDisplayPropertyInfo = Gdk.Display.Display
        type AttrGetType CursorDisplayPropertyInfo = Gdk.Display.Display
        type AttrLabel CursorDisplayPropertyInfo = "display"
        type AttrOrigin CursorDisplayPropertyInfo = Cursor
        attrGet = getCursorDisplay
        attrSet = undefined
        attrTransfer _ v = do
            unsafeCastTo Gdk.Display.Display v
        attrConstruct = constructCursorDisplay
        attrClear = undefined
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Cursor
    type instance O.AttributeList Cursor = CursorAttributeList
    type CursorAttributeList = ('[ '("cursorType", CursorCursorTypePropertyInfo), '("display", CursorDisplayPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    cursorCursorType :: AttrLabelProxy "cursorType"
    cursorCursorType = AttrLabelProxy

    cursorDisplay :: AttrLabelProxy "display"
    cursorDisplay = AttrLabelProxy

    #endif

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

    #endif

    -- method Cursor::new
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "cursor_type"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CursorType" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "cursor to create" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Cursor" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cursor_new" gdk_cursor_new ::
        CInt ->                                 -- cursor_type : TInterface (Name {namespace = "Gdk", name = "CursorType"})
        IO (Ptr Cursor)

    {-# DEPRECATED cursorNew ["(Since version 3.16)","Use 'GI.Gdk.Objects.Cursor.cursorNewForDisplay' instead."] #-}
    -- | Creates a new cursor from the set of builtin cursors for the default display.
    -- See 'GI.Gdk.Objects.Cursor.cursorNewForDisplay'.
    --
    -- To make the cursor invisible, use 'GI.Gdk.Enums.CursorTypeBlankCursor'.
    cursorNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Gdk.Enums.CursorType
        -- ^ /@cursorType@/: cursor to create
        -> m Cursor
        -- ^ __Returns:__ a new t'GI.Gdk.Objects.Cursor.Cursor'
    cursorNew :: CursorType -> m Cursor
    cursorNew cursorType :: CursorType
    cursorType = IO Cursor -> m Cursor
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Cursor -> m Cursor) -> IO Cursor -> m Cursor
    forall a b. (a -> b) -> a -> b
    $ do
        let cursorType' :: CInt
    cursorType' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (CursorType -> Int) -> CursorType -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CursorType -> Int
    forall a. Enum a => a -> Int
    fromEnum) CursorType
    cursorType
        Ptr Cursor
    result <- CInt -> IO (Ptr Cursor)
    gdk_cursor_new CInt
    cursorType'
        Text -> Ptr Cursor -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "cursorNew" Ptr Cursor
    result
        Cursor
    result' <- ((ManagedPtr Cursor -> Cursor) -> Ptr Cursor -> IO Cursor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Cursor -> Cursor
    Cursor) Ptr Cursor
    result
        Cursor -> IO Cursor
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cursor
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Cursor::new_for_display
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "display"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Display" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the #GdkDisplay for which the cursor will be created"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cursor_type"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CursorType" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "cursor to create" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Cursor" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cursor_new_for_display" gdk_cursor_new_for_display ::
        Ptr Gdk.Display.Display ->              -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
        CInt ->                                 -- cursor_type : TInterface (Name {namespace = "Gdk", name = "CursorType"})
        IO (Ptr Cursor)

    -- | Creates a new cursor from the set of builtin cursors.
    --
    -- /Since: 2.2/
    cursorNewForDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>
        a
        -- ^ /@display@/: the t'GI.Gdk.Objects.Display.Display' for which the cursor will be created
        -> Gdk.Enums.CursorType
        -- ^ /@cursorType@/: cursor to create
        -> m Cursor
        -- ^ __Returns:__ a new t'GI.Gdk.Objects.Cursor.Cursor'
    cursorNewForDisplay :: a -> CursorType -> m Cursor
    cursorNewForDisplay display :: a
    display cursorType :: CursorType
    cursorType = IO Cursor -> m Cursor
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Cursor -> m Cursor) -> IO Cursor -> m Cursor
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Display
    display' <- a -> IO (Ptr Display)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    display
        let cursorType' :: CInt
    cursorType' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (CursorType -> Int) -> CursorType -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CursorType -> Int
    forall a. Enum a => a -> Int
    fromEnum) CursorType
    cursorType
        Ptr Cursor
    result <- Ptr Display -> CInt -> IO (Ptr Cursor)
    gdk_cursor_new_for_display Ptr Display
    display' CInt
    cursorType'
        Text -> Ptr Cursor -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "cursorNewForDisplay" Ptr Cursor
    result
        Cursor
    result' <- ((ManagedPtr Cursor -> Cursor) -> Ptr Cursor -> IO Cursor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Cursor -> Cursor
    Cursor) Ptr Cursor
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    display
        Cursor -> IO Cursor
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cursor
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Cursor::new_from_name
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "display"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Display" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the #GdkDisplay for which the cursor will be created"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the cursor"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Cursor" })
    -- throws : False
    -- Skip return : False

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

    -- | Creates a new cursor by looking up /@name@/ in the current cursor
    -- theme.
    --
    -- A recommended set of cursor names that will work across different
    -- platforms can be found in the CSS specification:
    --
    -- * \"none\"
    -- * <<http://developer.gnome.org/gdk/stable/default_cursor.png>> \"default\"
    -- * <<http://developer.gnome.org/gdk/stable/help_cursor.png>> \"help\"
    -- * <<http://developer.gnome.org/gdk/stable/pointer_cursor.png>> \"pointer\"
    -- * <<http://developer.gnome.org/gdk/stable/context_menu_cursor.png>> \"context-menu\"
    -- * <<http://developer.gnome.org/gdk/stable/progress_cursor.png>> \"progress\"
    -- * <<http://developer.gnome.org/gdk/stable/wait_cursor.png>> \"wait\"
    -- * <<http://developer.gnome.org/gdk/stable/cell_cursor.png>> \"cell\"
    -- * <<http://developer.gnome.org/gdk/stable/crosshair_cursor.png>> \"crosshair\"
    -- * <<http://developer.gnome.org/gdk/stable/text_cursor.png>> \"text\"
    -- * <<http://developer.gnome.org/gdk/stable/vertical_text_cursor.png>> \"vertical-text\"
    -- * <<http://developer.gnome.org/gdk/stable/alias_cursor.png>> \"alias\"
    -- * <<http://developer.gnome.org/gdk/stable/copy_cursor.png>> \"copy\"
    -- * <<http://developer.gnome.org/gdk/stable/no_drop_cursor.png>> \"no-drop\"
    -- * <<http://developer.gnome.org/gdk/stable/move_cursor.png>> \"move\"
    -- * <<http://developer.gnome.org/gdk/stable/not_allowed_cursor.png>> \"not-allowed\"
    -- * <<http://developer.gnome.org/gdk/stable/grab_cursor.png>> \"grab\"
    -- * <<http://developer.gnome.org/gdk/stable/grabbing_cursor.png>> \"grabbing\"
    -- * <<http://developer.gnome.org/gdk/stable/all_scroll_cursor.png>> \"all-scroll\"
    -- * <<http://developer.gnome.org/gdk/stable/col_resize_cursor.png>> \"col-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/row_resize_cursor.png>> \"row-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/n_resize_cursor.png>> \"n-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/e_resize_cursor.png>> \"e-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/s_resize_cursor.png>> \"s-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/w_resize_cursor.png>> \"w-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/ne_resize_cursor.png>> \"ne-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/nw_resize_cursor.png>> \"nw-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/sw_resize_cursor.png>> \"sw-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/se_resize_cursor.png>> \"se-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/ew_resize_cursor.png>> \"ew-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/ns_resize_cursor.png>> \"ns-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/nesw_resize_cursor.png>> \"nesw-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/nwse_resize_cursor.png>> \"nwse-resize\"
    -- * <<http://developer.gnome.org/gdk/stable/zoom_in_cursor.png>> \"zoom-in\"
    -- * <<http://developer.gnome.org/gdk/stable/zoom_out_cursor.png>> \"zoom-out\"
    --
    --
    -- /Since: 2.8/
    cursorNewFromName ::
        (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>
        a
        -- ^ /@display@/: the t'GI.Gdk.Objects.Display.Display' for which the cursor will be created
        -> T.Text
        -- ^ /@name@/: the name of the cursor
        -> m (Maybe Cursor)
        -- ^ __Returns:__ a new t'GI.Gdk.Objects.Cursor.Cursor', or 'P.Nothing' if there is no
        --   cursor with the given name
    cursorNewFromName :: a -> Text -> m (Maybe Cursor)
    cursorNewFromName display :: a
    display name :: Text
    name = IO (Maybe Cursor) -> m (Maybe Cursor)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Cursor) -> m (Maybe Cursor))
    -> IO (Maybe Cursor) -> m (Maybe Cursor)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Display
    display' <- a -> IO (Ptr Display)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    display
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        Ptr Cursor
    result <- Ptr Display -> CString -> IO (Ptr Cursor)
    gdk_cursor_new_from_name Ptr Display
    display' CString
    name'
        Maybe Cursor
    maybeResult <- Ptr Cursor -> (Ptr Cursor -> IO Cursor) -> IO (Maybe Cursor)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Cursor
    result ((Ptr Cursor -> IO Cursor) -> IO (Maybe Cursor))
    -> (Ptr Cursor -> IO Cursor) -> IO (Maybe Cursor)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Cursor
    result' -> do
            Cursor
    result'' <- ((ManagedPtr Cursor -> Cursor) -> Ptr Cursor -> IO Cursor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Cursor -> Cursor
    Cursor) Ptr Cursor
    result'
            Cursor -> IO Cursor
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cursor
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    display
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        Maybe Cursor -> IO (Maybe Cursor)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Cursor
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Cursor::new_from_pixbuf
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "display"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Display" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the #GdkDisplay for which the cursor will be created"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pixbuf"
    --           , argType =
    --               TInterface Name { namespace = "GdkPixbuf" , name = "Pixbuf" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GdkPixbuf containing the cursor image"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the horizontal offset of the \8220hotspot\8221 of the cursor."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the vertical offset of the \8220hotspot\8221 of the cursor."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Cursor" })
    -- throws : False
    -- Skip return : False

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

    -- | Creates a new cursor from a pixbuf.
    --
    -- Not all GDK backends support RGBA cursors. If they are not
    -- supported, a monochrome approximation will be displayed.
    -- The functions 'GI.Gdk.Objects.Display.displaySupportsCursorAlpha' and
    -- 'GI.Gdk.Objects.Display.displaySupportsCursorColor' can be used to determine
    -- whether RGBA cursors are supported;
    -- 'GI.Gdk.Objects.Display.displayGetDefaultCursorSize' and
    -- 'GI.Gdk.Objects.Display.displayGetMaximalCursorSize' give information about
    -- cursor sizes.
    --
    -- If /@x@/ or /@y@/ are @-1@, the pixbuf must have
    -- options named “x_hot” and “y_hot”, resp., containing
    -- integer values between @0@ and the width resp. height of
    -- the pixbuf. (Since: 3.0)
    --
    -- On the X backend, support for RGBA cursors requires a
    -- sufficently new version of the X Render extension.
    --
    -- /Since: 2.4/
    cursorNewFromPixbuf ::
        (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a, GdkPixbuf.Pixbuf.IsPixbuf b) =>
        a
        -- ^ /@display@/: the t'GI.Gdk.Objects.Display.Display' for which the cursor will be created
        -> b
        -- ^ /@pixbuf@/: the t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' containing the cursor image
        -> Int32
        -- ^ /@x@/: the horizontal offset of the “hotspot” of the cursor.
        -> Int32
        -- ^ /@y@/: the vertical offset of the “hotspot” of the cursor.
        -> m Cursor
        -- ^ __Returns:__ a new t'GI.Gdk.Objects.Cursor.Cursor'.
    cursorNewFromPixbuf :: a -> b -> Int32 -> Int32 -> m Cursor
    cursorNewFromPixbuf display :: a
    display pixbuf :: b
    pixbuf x :: Int32
    x y :: Int32
    y = IO Cursor -> m Cursor
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Cursor -> m Cursor) -> IO Cursor -> m Cursor
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Display
    display' <- a -> IO (Ptr Display)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    display
        Ptr Pixbuf
    pixbuf' <- b -> IO (Ptr Pixbuf)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    pixbuf
        Ptr Cursor
    result <- Ptr Display -> Ptr Pixbuf -> Int32 -> Int32 -> IO (Ptr Cursor)
    gdk_cursor_new_from_pixbuf Ptr Display
    display' Ptr Pixbuf
    pixbuf' Int32
    x Int32
    y
        Text -> Ptr Cursor -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "cursorNewFromPixbuf" Ptr Cursor
    result
        Cursor
    result' <- ((ManagedPtr Cursor -> Cursor) -> Ptr Cursor -> IO Cursor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Cursor -> Cursor
    Cursor) Ptr Cursor
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    display
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    pixbuf
        Cursor -> IO Cursor
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cursor
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Cursor::new_from_surface
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "display"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "Display" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the #GdkDisplay for which the cursor will be created"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "surface"
    --           , argType =
    --               TInterface Name { namespace = "cairo" , name = "Surface" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the cairo image surface containing the cursor pixel data"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x"
    --           , argType = TBasicType TDouble
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the horizontal offset of the \8220hotspot\8221 of the cursor"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y"
    --           , argType = TBasicType TDouble
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the vertical offset of the \8220hotspot\8221 of the cursor"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Cursor" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cursor_new_from_surface" gdk_cursor_new_from_surface ::
        Ptr Gdk.Display.Display ->              -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
        Ptr Cairo.Surface.Surface ->            -- surface : TInterface (Name {namespace = "cairo", name = "Surface"})
        CDouble ->                              -- x : TBasicType TDouble
        CDouble ->                              -- y : TBasicType TDouble
        IO (Ptr Cursor)

    -- | Creates a new cursor from a cairo image surface.
    --
    -- Not all GDK backends support RGBA cursors. If they are not
    -- supported, a monochrome approximation will be displayed.
    -- The functions 'GI.Gdk.Objects.Display.displaySupportsCursorAlpha' and
    -- 'GI.Gdk.Objects.Display.displaySupportsCursorColor' can be used to determine
    -- whether RGBA cursors are supported;
    -- 'GI.Gdk.Objects.Display.displayGetDefaultCursorSize' and
    -- 'GI.Gdk.Objects.Display.displayGetMaximalCursorSize' give information about
    -- cursor sizes.
    --
    -- On the X backend, support for RGBA cursors requires a
    -- sufficently new version of the X Render extension.
    --
    -- /Since: 3.10/
    cursorNewFromSurface ::
        (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>
        a
        -- ^ /@display@/: the t'GI.Gdk.Objects.Display.Display' for which the cursor will be created
        -> Cairo.Surface.Surface
        -- ^ /@surface@/: the cairo image surface containing the cursor pixel data
        -> Double
        -- ^ /@x@/: the horizontal offset of the “hotspot” of the cursor
        -> Double
        -- ^ /@y@/: the vertical offset of the “hotspot” of the cursor
        -> m Cursor
        -- ^ __Returns:__ a new t'GI.Gdk.Objects.Cursor.Cursor'.
    cursorNewFromSurface :: a -> Surface -> Double -> Double -> m Cursor
    cursorNewFromSurface display :: a
    display surface :: Surface
    surface x :: Double
    x y :: Double
    y = IO Cursor -> m Cursor
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Cursor -> m Cursor) -> IO Cursor -> m Cursor
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Display
    display' <- a -> IO (Ptr Display)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    display
        Ptr Surface
    surface' <- Surface -> IO (Ptr Surface)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Surface
    surface
        let x' :: CDouble
    x' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    x
        let y' :: CDouble
    y' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    y
        Ptr Cursor
    result <- Ptr Display -> Ptr Surface -> CDouble -> CDouble -> IO (Ptr Cursor)
    gdk_cursor_new_from_surface Ptr Display
    display' Ptr Surface
    surface' CDouble
    x' CDouble
    y'
        Text -> Ptr Cursor -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "cursorNewFromSurface" Ptr Cursor
    result
        Cursor
    result' <- ((ManagedPtr Cursor -> Cursor) -> Ptr Cursor -> IO Cursor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Cursor -> Cursor
    Cursor) Ptr Cursor
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    display
        Surface -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Surface
    surface
        Cursor -> IO Cursor
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cursor
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "gdk_cursor_get_cursor_type" gdk_cursor_get_cursor_type ::
        Ptr Cursor ->                           -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
        IO CInt

    -- | Returns the cursor type for this cursor.
    --
    -- /Since: 2.22/
    cursorGetCursorType ::
        (B.CallStack.HasCallStack, MonadIO m, IsCursor a) =>
        a
        -- ^ /@cursor@/: a t'GI.Gdk.Objects.Cursor.Cursor'
        -> m Gdk.Enums.CursorType
        -- ^ __Returns:__ a t'GI.Gdk.Enums.CursorType'
    cursorGetCursorType :: a -> m CursorType
    cursorGetCursorType cursor :: a
    cursor = IO CursorType -> m CursorType
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CursorType -> m CursorType) -> IO CursorType -> m CursorType
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Cursor
    cursor' <- a -> IO (Ptr Cursor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cursor
        CInt
    result <- Ptr Cursor -> IO CInt
    gdk_cursor_get_cursor_type Ptr Cursor
    cursor'
        let result' :: CursorType
    result' = (Int -> CursorType
    forall a. Enum a => Int -> a
    toEnum (Int -> CursorType) -> (CInt -> Int) -> CInt -> CursorType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    cursor
        CursorType -> IO CursorType
    forall (m :: * -> *) a. Monad m => a -> m a
    return CursorType
    result'

    #if defined(ENABLE_OVERLOADING)
    data CursorGetCursorTypeMethodInfo
    instance (signature ~ (m Gdk.Enums.CursorType), MonadIO m, IsCursor a) => O.MethodInfo CursorGetCursorTypeMethodInfo a signature where
        overloadedMethod = cursorGetCursorType

    #endif

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

    -- | Returns the display on which the t'GI.Gdk.Objects.Cursor.Cursor' is defined.
    --
    -- /Since: 2.2/
    cursorGetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsCursor a) =>
        a
        -- ^ /@cursor@/: a t'GI.Gdk.Objects.Cursor.Cursor'.
        -> m Gdk.Display.Display
        -- ^ __Returns:__ the t'GI.Gdk.Objects.Display.Display' associated to /@cursor@/
    cursorGetDisplay :: a -> m Display
    cursorGetDisplay cursor :: a
    cursor = IO Display -> m Display
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Display -> m Display) -> IO Display -> m Display
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Cursor
    cursor' <- a -> IO (Ptr Cursor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cursor
        Ptr Display
    result <- Ptr Cursor -> IO (Ptr Display)
    gdk_cursor_get_display Ptr Cursor
    cursor'
        Text -> Ptr Display -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "cursorGetDisplay" Ptr Display
    result
        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
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    cursor
        Display -> IO Display
    forall (m :: * -> *) a. Monad m => a -> m a
    return Display
    result'

    #if defined(ENABLE_OVERLOADING)
    data CursorGetDisplayMethodInfo
    instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsCursor a) => O.MethodInfo CursorGetDisplayMethodInfo a signature where
        overloadedMethod = cursorGetDisplay

    #endif

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

    foreign import ccall "gdk_cursor_get_image" gdk_cursor_get_image ::
        Ptr Cursor ->                           -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
        IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

    -- | Returns a t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' with the image used to display the cursor.
    --
    -- Note that depending on the capabilities of the windowing system and
    -- on the cursor, GDK may not be able to obtain the image data. In this
    -- case, 'P.Nothing' is returned.
    --
    -- /Since: 2.8/
    cursorGetImage ::
        (B.CallStack.HasCallStack, MonadIO m, IsCursor a) =>
        a
        -- ^ /@cursor@/: a t'GI.Gdk.Objects.Cursor.Cursor'
        -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
        -- ^ __Returns:__ a t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' representing
        --   /@cursor@/, or 'P.Nothing'
    cursorGetImage :: a -> m (Maybe Pixbuf)
    cursorGetImage cursor :: a
    cursor = IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Pixbuf) -> m (Maybe Pixbuf))
    -> IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Cursor
    cursor' <- a -> IO (Ptr Cursor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cursor
        Ptr Pixbuf
    result <- Ptr Cursor -> IO (Ptr Pixbuf)
    gdk_cursor_get_image Ptr Cursor
    cursor'
        Maybe Pixbuf
    maybeResult <- Ptr Pixbuf -> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Pixbuf
    result ((Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf))
    -> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Pixbuf
    result' -> do
            Pixbuf
    result'' <- ((ManagedPtr Pixbuf -> Pixbuf) -> Ptr Pixbuf -> IO Pixbuf
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Pixbuf -> Pixbuf
    GdkPixbuf.Pixbuf.Pixbuf) Ptr Pixbuf
    result'
            Pixbuf -> IO Pixbuf
    forall (m :: * -> *) a. Monad m => a -> m a
    return Pixbuf
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    cursor
        Maybe Pixbuf -> IO (Maybe Pixbuf)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Pixbuf
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data CursorGetImageMethodInfo
    instance (signature ~ (m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsCursor a) => O.MethodInfo CursorGetImageMethodInfo a signature where
        overloadedMethod = cursorGetImage

    #endif

    -- method Cursor::get_surface
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "cursor"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Cursor" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkCursor" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x_hot"
    --           , argType = TBasicType TDouble
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "Location to store the hotspot x position,\n  or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "y_hot"
    --           , argType = TBasicType TDouble
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "Location to store the hotspot y position,\n  or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "cairo" , name = "Surface" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cursor_get_surface" gdk_cursor_get_surface ::
        Ptr Cursor ->                           -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
        Ptr CDouble ->                          -- x_hot : TBasicType TDouble
        Ptr CDouble ->                          -- y_hot : TBasicType TDouble
        IO (Ptr Cairo.Surface.Surface)

    -- | Returns a cairo image surface with the image used to display the cursor.
    --
    -- Note that depending on the capabilities of the windowing system and
    -- on the cursor, GDK may not be able to obtain the image data. In this
    -- case, 'P.Nothing' is returned.
    --
    -- /Since: 3.10/
    cursorGetSurface ::
        (B.CallStack.HasCallStack, MonadIO m, IsCursor a) =>
        a
        -- ^ /@cursor@/: a t'GI.Gdk.Objects.Cursor.Cursor'
        -> m ((Maybe Cairo.Surface.Surface, Double, Double))
        -- ^ __Returns:__ a t'GI.Cairo.Structs.Surface.Surface'
        --   representing /@cursor@/, or 'P.Nothing'
    cursorGetSurface :: a -> m (Maybe Surface, Double, Double)
    cursorGetSurface cursor :: a
    cursor = IO (Maybe Surface, Double, Double)
    -> m (Maybe Surface, Double, Double)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Surface, Double, Double)
     -> m (Maybe Surface, Double, Double))
    -> IO (Maybe Surface, Double, Double)
    -> m (Maybe Surface, Double, Double)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Cursor
    cursor' <- a -> IO (Ptr Cursor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cursor
        Ptr CDouble
    xHot <- IO (Ptr CDouble)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr CDouble)
        Ptr CDouble
    yHot <- IO (Ptr CDouble)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr CDouble)
        Ptr Surface
    result <- Ptr Cursor -> Ptr CDouble -> Ptr CDouble -> IO (Ptr Surface)
    gdk_cursor_get_surface Ptr Cursor
    cursor' Ptr CDouble
    xHot Ptr CDouble
    yHot
        Maybe Surface
    maybeResult <- Ptr Surface -> (Ptr Surface -> IO Surface) -> IO (Maybe Surface)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Surface
    result ((Ptr Surface -> IO Surface) -> IO (Maybe Surface))
    -> (Ptr Surface -> IO Surface) -> IO (Maybe Surface)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Surface
    result' -> do
            Surface
    result'' <- ((ManagedPtr Surface -> Surface) -> Ptr Surface -> IO Surface
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Surface -> Surface
    Cairo.Surface.Surface) Ptr Surface
    result'
            Surface -> IO Surface
    forall (m :: * -> *) a. Monad m => a -> m a
    return Surface
    result''
        CDouble
    xHot' <- Ptr CDouble -> IO CDouble
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CDouble
    xHot
        let xHot'' :: Double
    xHot'' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    xHot'
        CDouble
    yHot' <- Ptr CDouble -> IO CDouble
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CDouble
    yHot
        let yHot'' :: Double
    yHot'' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    yHot'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    cursor
        Ptr CDouble -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CDouble
    xHot
        Ptr CDouble -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr CDouble
    yHot
        (Maybe Surface, Double, Double)
    -> IO (Maybe Surface, Double, Double)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Surface
    maybeResult, Double
    xHot'', Double
    yHot'')

    #if defined(ENABLE_OVERLOADING)
    data CursorGetSurfaceMethodInfo
    instance (signature ~ (m ((Maybe Cairo.Surface.Surface, Double, Double))), MonadIO m, IsCursor a) => O.MethodInfo CursorGetSurfaceMethodInfo a signature where
        overloadedMethod = cursorGetSurface

    #endif

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

    foreign import ccall "gdk_cursor_ref" gdk_cursor_ref ::
        Ptr Cursor ->                           -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
        IO (Ptr Cursor)

    {-# DEPRECATED cursorRef ["(Since version 3.0)","Use 'GI.GObject.Objects.Object.objectRef' instead"] #-}
    -- | Adds a reference to /@cursor@/.
    cursorRef ::
        (B.CallStack.HasCallStack, MonadIO m, IsCursor a) =>
        a
        -- ^ /@cursor@/: a t'GI.Gdk.Objects.Cursor.Cursor'
        -> m Cursor
        -- ^ __Returns:__ Same /@cursor@/ that was passed in
    cursorRef :: a -> m Cursor
    cursorRef cursor :: a
    cursor = IO Cursor -> m Cursor
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Cursor -> m Cursor) -> IO Cursor -> m Cursor
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Cursor
    cursor' <- a -> IO (Ptr Cursor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cursor
        Ptr Cursor
    result <- Ptr Cursor -> IO (Ptr Cursor)
    gdk_cursor_ref Ptr Cursor
    cursor'
        Text -> Ptr Cursor -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "cursorRef" Ptr Cursor
    result
        Cursor
    result' <- ((ManagedPtr Cursor -> Cursor) -> Ptr Cursor -> IO Cursor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Cursor -> Cursor
    Cursor) Ptr Cursor
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    cursor
        Cursor -> IO Cursor
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cursor
    result'

    #if defined(ENABLE_OVERLOADING)
    data CursorRefMethodInfo
    instance (signature ~ (m Cursor), MonadIO m, IsCursor a) => O.MethodInfo CursorRefMethodInfo a signature where
        overloadedMethod = cursorRef

    #endif

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

    foreign import ccall "gdk_cursor_unref" gdk_cursor_unref ::
        Ptr Cursor ->                           -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
        IO ()

    {-# DEPRECATED cursorUnref ["(Since version 3.0)","Use 'GI.GObject.Objects.Object.objectUnref' instead"] #-}
    -- | Removes a reference from /@cursor@/, deallocating the cursor
    -- if no references remain.
    cursorUnref ::
        (B.CallStack.HasCallStack, MonadIO m, IsCursor a) =>
        a
        -- ^ /@cursor@/: a t'GI.Gdk.Objects.Cursor.Cursor'
        -> m ()
    cursorUnref :: a -> m ()
    cursorUnref cursor :: a
    cursor = 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 Cursor
    cursor' <- a -> IO (Ptr Cursor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    cursor
        Ptr Cursor -> IO ()
    gdk_cursor_unref Ptr Cursor
    cursor'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    cursor
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data CursorUnrefMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsCursor a) => O.MethodInfo CursorUnrefMethodInfo a signature where
        overloadedMethod = cursorUnref

    #endif