{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Clutter.Objects.Backend.Backend' is an opaque structure whose
-- members cannot be directly accessed.
-- 
-- /Since: 0.4/

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

module GI.Clutter.Objects.Backend
    ( 

-- * Exported types
    Backend(..)                             ,
    IsBackend                               ,
    toBackend                               ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDoubleClickDistance]("GI.Clutter.Objects.Backend#g:method:getDoubleClickDistance"), [getDoubleClickTime]("GI.Clutter.Objects.Backend#g:method:getDoubleClickTime"), [getFontName]("GI.Clutter.Objects.Backend#g:method:getFontName"), [getFontOptions]("GI.Clutter.Objects.Backend#g:method:getFontOptions"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getResolution]("GI.Clutter.Objects.Backend#g:method:getResolution").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDoubleClickDistance]("GI.Clutter.Objects.Backend#g:method:setDoubleClickDistance"), [setDoubleClickTime]("GI.Clutter.Objects.Backend#g:method:setDoubleClickTime"), [setFontName]("GI.Clutter.Objects.Backend#g:method:setFontName"), [setFontOptions]("GI.Clutter.Objects.Backend#g:method:setFontOptions"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setResolution]("GI.Clutter.Objects.Backend#g:method:setResolution").

#if defined(ENABLE_OVERLOADING)
    ResolveBackendMethod                    ,
#endif

-- ** getDoubleClickDistance #method:getDoubleClickDistance#

#if defined(ENABLE_OVERLOADING)
    BackendGetDoubleClickDistanceMethodInfo ,
#endif
    backendGetDoubleClickDistance           ,


-- ** getDoubleClickTime #method:getDoubleClickTime#

#if defined(ENABLE_OVERLOADING)
    BackendGetDoubleClickTimeMethodInfo     ,
#endif
    backendGetDoubleClickTime               ,


-- ** getFontName #method:getFontName#

#if defined(ENABLE_OVERLOADING)
    BackendGetFontNameMethodInfo            ,
#endif
    backendGetFontName                      ,


-- ** getFontOptions #method:getFontOptions#

#if defined(ENABLE_OVERLOADING)
    BackendGetFontOptionsMethodInfo         ,
#endif
    backendGetFontOptions                   ,


-- ** getResolution #method:getResolution#

#if defined(ENABLE_OVERLOADING)
    BackendGetResolutionMethodInfo          ,
#endif
    backendGetResolution                    ,


-- ** setDoubleClickDistance #method:setDoubleClickDistance#

#if defined(ENABLE_OVERLOADING)
    BackendSetDoubleClickDistanceMethodInfo ,
#endif
    backendSetDoubleClickDistance           ,


-- ** setDoubleClickTime #method:setDoubleClickTime#

#if defined(ENABLE_OVERLOADING)
    BackendSetDoubleClickTimeMethodInfo     ,
#endif
    backendSetDoubleClickTime               ,


-- ** setFontName #method:setFontName#

#if defined(ENABLE_OVERLOADING)
    BackendSetFontNameMethodInfo            ,
#endif
    backendSetFontName                      ,


-- ** setFontOptions #method:setFontOptions#

#if defined(ENABLE_OVERLOADING)
    BackendSetFontOptionsMethodInfo         ,
#endif
    backendSetFontOptions                   ,


-- ** setResolution #method:setResolution#

#if defined(ENABLE_OVERLOADING)
    BackendSetResolutionMethodInfo          ,
#endif
    backendSetResolution                    ,




 -- * Signals


-- ** fontChanged #signal:fontChanged#

    BackendFontChangedCallback              ,
#if defined(ENABLE_OVERLOADING)
    BackendFontChangedSignalInfo            ,
#endif
    afterBackendFontChanged                 ,
    onBackendFontChanged                    ,


-- ** resolutionChanged #signal:resolutionChanged#

    BackendResolutionChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    BackendResolutionChangedSignalInfo      ,
#endif
    afterBackendResolutionChanged           ,
    onBackendResolutionChanged              ,


-- ** settingsChanged #signal:settingsChanged#

    BackendSettingsChangedCallback          ,
#if defined(ENABLE_OVERLOADING)
    BackendSettingsChangedSignalInfo        ,
#endif
    afterBackendSettingsChanged             ,
    onBackendSettingsChanged                ,




    ) 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.Coerce as Coerce
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 GHC.Records as R

import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "clutter_backend_get_type"
    c_clutter_backend_get_type :: IO B.Types.GType

instance B.Types.TypedObject Backend where
    glibType :: IO GType
glibType = IO GType
c_clutter_backend_get_type

instance B.Types.GObject Backend

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

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

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

-- | Convert 'Backend' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Backend) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_backend_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Backend -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Backend
P.Nothing = Ptr GValue -> Ptr Backend -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Backend
forall a. Ptr a
FP.nullPtr :: FP.Ptr Backend)
    gvalueSet_ Ptr GValue
gv (P.Just Backend
obj) = Backend -> (Ptr Backend -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Backend
obj (Ptr GValue -> Ptr Backend -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Backend)
gvalueGet_ Ptr GValue
gv = do
        Ptr Backend
ptr <- Ptr GValue -> IO (Ptr Backend)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Backend)
        if Ptr Backend
ptr Ptr Backend -> Ptr Backend -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Backend
forall a. Ptr a
FP.nullPtr
        then Backend -> Maybe Backend
forall a. a -> Maybe a
P.Just (Backend -> Maybe Backend) -> IO Backend -> IO (Maybe Backend)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Backend -> Backend) -> Ptr Backend -> IO Backend
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Backend -> Backend
Backend Ptr Backend
ptr
        else Maybe Backend -> IO (Maybe Backend)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Backend
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveBackendMethod (t :: Symbol) (o :: *) :: * where
    ResolveBackendMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveBackendMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveBackendMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveBackendMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveBackendMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveBackendMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveBackendMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveBackendMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveBackendMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveBackendMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveBackendMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveBackendMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveBackendMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveBackendMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveBackendMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveBackendMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveBackendMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveBackendMethod "getDoubleClickDistance" o = BackendGetDoubleClickDistanceMethodInfo
    ResolveBackendMethod "getDoubleClickTime" o = BackendGetDoubleClickTimeMethodInfo
    ResolveBackendMethod "getFontName" o = BackendGetFontNameMethodInfo
    ResolveBackendMethod "getFontOptions" o = BackendGetFontOptionsMethodInfo
    ResolveBackendMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveBackendMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveBackendMethod "getResolution" o = BackendGetResolutionMethodInfo
    ResolveBackendMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveBackendMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveBackendMethod "setDoubleClickDistance" o = BackendSetDoubleClickDistanceMethodInfo
    ResolveBackendMethod "setDoubleClickTime" o = BackendSetDoubleClickTimeMethodInfo
    ResolveBackendMethod "setFontName" o = BackendSetFontNameMethodInfo
    ResolveBackendMethod "setFontOptions" o = BackendSetFontOptionsMethodInfo
    ResolveBackendMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveBackendMethod "setResolution" o = BackendSetResolutionMethodInfo
    ResolveBackendMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveBackendMethod t Backend, O.OverloadedMethod info Backend p, R.HasField t Backend p) => R.HasField t Backend p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveBackendMethod t Backend, O.OverloadedMethodInfo info Backend) => OL.IsLabel t (O.MethodProxy info Backend) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal Backend::font-changed
-- | The [fontChanged](#g:signal:fontChanged) signal is emitted each time the font options
-- have been changed through t'GI.Clutter.Objects.Settings.Settings'.
-- 
-- /Since: 1.0/
type BackendFontChangedCallback =
    IO ()

type C_BackendFontChangedCallback =
    Ptr Backend ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_BackendFontChangedCallback :: 
    GObject a => (a -> BackendFontChangedCallback) ->
    C_BackendFontChangedCallback
wrap_BackendFontChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendFontChangedCallback a -> IO ()
gi'cb Ptr Backend
gi'selfPtr Ptr ()
_ = do
    Ptr Backend -> (Backend -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Backend
gi'selfPtr ((Backend -> IO ()) -> IO ()) -> (Backend -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Backend
gi'self -> a -> IO ()
gi'cb (Backend -> a
Coerce.coerce Backend
gi'self) 


-- | Connect a signal handler for the [fontChanged](#signal:fontChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' backend #fontChanged callback
-- @
-- 
-- 
onBackendFontChanged :: (IsBackend a, MonadIO m) => a -> ((?self :: a) => BackendFontChangedCallback) -> m SignalHandlerId
onBackendFontChanged :: forall a (m :: * -> *).
(IsBackend a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onBackendFontChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BackendFontChangedCallback
wrapped' = (a -> IO ()) -> C_BackendFontChangedCallback
forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendFontChangedCallback a -> IO ()
wrapped
    FunPtr C_BackendFontChangedCallback
wrapped'' <- C_BackendFontChangedCallback
-> IO (FunPtr C_BackendFontChangedCallback)
mk_BackendFontChangedCallback C_BackendFontChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_BackendFontChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"font-changed" FunPtr C_BackendFontChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [fontChanged](#signal:fontChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' backend #fontChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterBackendFontChanged :: (IsBackend a, MonadIO m) => a -> ((?self :: a) => BackendFontChangedCallback) -> m SignalHandlerId
afterBackendFontChanged :: forall a (m :: * -> *).
(IsBackend a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterBackendFontChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BackendFontChangedCallback
wrapped' = (a -> IO ()) -> C_BackendFontChangedCallback
forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendFontChangedCallback a -> IO ()
wrapped
    FunPtr C_BackendFontChangedCallback
wrapped'' <- C_BackendFontChangedCallback
-> IO (FunPtr C_BackendFontChangedCallback)
mk_BackendFontChangedCallback C_BackendFontChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_BackendFontChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"font-changed" FunPtr C_BackendFontChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BackendFontChangedSignalInfo
instance SignalInfo BackendFontChangedSignalInfo where
    type HaskellCallbackType BackendFontChangedSignalInfo = BackendFontChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BackendFontChangedCallback cb
        cb'' <- mk_BackendFontChangedCallback cb'
        connectSignalFunPtr obj "font-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend::font-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#g:signal:fontChanged"})

#endif

-- signal Backend::resolution-changed
-- | The [resolutionChanged](#g:signal:resolutionChanged) signal is emitted each time the font
-- resolutions has been changed through t'GI.Clutter.Objects.Settings.Settings'.
-- 
-- /Since: 1.0/
type BackendResolutionChangedCallback =
    IO ()

type C_BackendResolutionChangedCallback =
    Ptr Backend ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_BackendResolutionChangedCallback :: 
    GObject a => (a -> BackendResolutionChangedCallback) ->
    C_BackendResolutionChangedCallback
wrap_BackendResolutionChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendResolutionChangedCallback a -> IO ()
gi'cb Ptr Backend
gi'selfPtr Ptr ()
_ = do
    Ptr Backend -> (Backend -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Backend
gi'selfPtr ((Backend -> IO ()) -> IO ()) -> (Backend -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Backend
gi'self -> a -> IO ()
gi'cb (Backend -> a
Coerce.coerce Backend
gi'self) 


-- | Connect a signal handler for the [resolutionChanged](#signal:resolutionChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' backend #resolutionChanged callback
-- @
-- 
-- 
onBackendResolutionChanged :: (IsBackend a, MonadIO m) => a -> ((?self :: a) => BackendResolutionChangedCallback) -> m SignalHandlerId
onBackendResolutionChanged :: forall a (m :: * -> *).
(IsBackend a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onBackendResolutionChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BackendFontChangedCallback
wrapped' = (a -> IO ()) -> C_BackendFontChangedCallback
forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendResolutionChangedCallback a -> IO ()
wrapped
    FunPtr C_BackendFontChangedCallback
wrapped'' <- C_BackendFontChangedCallback
-> IO (FunPtr C_BackendFontChangedCallback)
mk_BackendResolutionChangedCallback C_BackendFontChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_BackendFontChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"resolution-changed" FunPtr C_BackendFontChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [resolutionChanged](#signal:resolutionChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' backend #resolutionChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterBackendResolutionChanged :: (IsBackend a, MonadIO m) => a -> ((?self :: a) => BackendResolutionChangedCallback) -> m SignalHandlerId
afterBackendResolutionChanged :: forall a (m :: * -> *).
(IsBackend a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterBackendResolutionChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BackendFontChangedCallback
wrapped' = (a -> IO ()) -> C_BackendFontChangedCallback
forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendResolutionChangedCallback a -> IO ()
wrapped
    FunPtr C_BackendFontChangedCallback
wrapped'' <- C_BackendFontChangedCallback
-> IO (FunPtr C_BackendFontChangedCallback)
mk_BackendResolutionChangedCallback C_BackendFontChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_BackendFontChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"resolution-changed" FunPtr C_BackendFontChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BackendResolutionChangedSignalInfo
instance SignalInfo BackendResolutionChangedSignalInfo where
    type HaskellCallbackType BackendResolutionChangedSignalInfo = BackendResolutionChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BackendResolutionChangedCallback cb
        cb'' <- mk_BackendResolutionChangedCallback cb'
        connectSignalFunPtr obj "resolution-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend::resolution-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#g:signal:resolutionChanged"})

#endif

-- signal Backend::settings-changed
-- | The [settingsChanged](#g:signal:settingsChanged) signal is emitted each time the t'GI.Clutter.Objects.Settings.Settings'
-- properties have been changed.
-- 
-- /Since: 1.4/
type BackendSettingsChangedCallback =
    IO ()

type C_BackendSettingsChangedCallback =
    Ptr Backend ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_BackendSettingsChangedCallback :: 
    GObject a => (a -> BackendSettingsChangedCallback) ->
    C_BackendSettingsChangedCallback
wrap_BackendSettingsChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendSettingsChangedCallback a -> IO ()
gi'cb Ptr Backend
gi'selfPtr Ptr ()
_ = do
    Ptr Backend -> (Backend -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Backend
gi'selfPtr ((Backend -> IO ()) -> IO ()) -> (Backend -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Backend
gi'self -> a -> IO ()
gi'cb (Backend -> a
Coerce.coerce Backend
gi'self) 


-- | Connect a signal handler for the [settingsChanged](#signal:settingsChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' backend #settingsChanged callback
-- @
-- 
-- 
onBackendSettingsChanged :: (IsBackend a, MonadIO m) => a -> ((?self :: a) => BackendSettingsChangedCallback) -> m SignalHandlerId
onBackendSettingsChanged :: forall a (m :: * -> *).
(IsBackend a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onBackendSettingsChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BackendFontChangedCallback
wrapped' = (a -> IO ()) -> C_BackendFontChangedCallback
forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendSettingsChangedCallback a -> IO ()
wrapped
    FunPtr C_BackendFontChangedCallback
wrapped'' <- C_BackendFontChangedCallback
-> IO (FunPtr C_BackendFontChangedCallback)
mk_BackendSettingsChangedCallback C_BackendFontChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_BackendFontChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"settings-changed" FunPtr C_BackendFontChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [settingsChanged](#signal:settingsChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' backend #settingsChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterBackendSettingsChanged :: (IsBackend a, MonadIO m) => a -> ((?self :: a) => BackendSettingsChangedCallback) -> m SignalHandlerId
afterBackendSettingsChanged :: forall a (m :: * -> *).
(IsBackend a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterBackendSettingsChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BackendFontChangedCallback
wrapped' = (a -> IO ()) -> C_BackendFontChangedCallback
forall a. GObject a => (a -> IO ()) -> C_BackendFontChangedCallback
wrap_BackendSettingsChangedCallback a -> IO ()
wrapped
    FunPtr C_BackendFontChangedCallback
wrapped'' <- C_BackendFontChangedCallback
-> IO (FunPtr C_BackendFontChangedCallback)
mk_BackendSettingsChangedCallback C_BackendFontChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_BackendFontChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"settings-changed" FunPtr C_BackendFontChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BackendSettingsChangedSignalInfo
instance SignalInfo BackendSettingsChangedSignalInfo where
    type HaskellCallbackType BackendSettingsChangedSignalInfo = BackendSettingsChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BackendSettingsChangedCallback cb
        cb'' <- mk_BackendSettingsChangedCallback cb'
        connectSignalFunPtr obj "settings-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend::settings-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#g:signal:settingsChanged"})

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Backend = BackendSignalList
type BackendSignalList = ('[ '("fontChanged", BackendFontChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("resolutionChanged", BackendResolutionChangedSignalInfo), '("settingsChanged", BackendSettingsChangedSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "clutter_backend_get_double_click_distance" clutter_backend_get_double_click_distance :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    IO Word32

{-# DEPRECATED backendGetDoubleClickDistance ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-distance/@ instead"] #-}
-- | Retrieves the distance used to verify a double click event
-- 
-- /Since: 0.4/
backendGetDoubleClickDistance ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> m Word32
    -- ^ __Returns:__ a distance, in pixels.
backendGetDoubleClickDistance :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> m Word32
backendGetDoubleClickDistance a
backend = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    Word32
result <- Ptr Backend -> IO Word32
clutter_backend_get_double_click_distance Ptr Backend
backend'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data BackendGetDoubleClickDistanceMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsBackend a) => O.OverloadedMethod BackendGetDoubleClickDistanceMethodInfo a signature where
    overloadedMethod = backendGetDoubleClickDistance

instance O.OverloadedMethodInfo BackendGetDoubleClickDistanceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendGetDoubleClickDistance",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendGetDoubleClickDistance"
        })


#endif

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

foreign import ccall "clutter_backend_get_double_click_time" clutter_backend_get_double_click_time :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    IO Word32

{-# DEPRECATED backendGetDoubleClickTime ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-time/@ instead"] #-}
-- | Gets the maximum time between two button press events, as set
-- by 'GI.Clutter.Objects.Backend.backendSetDoubleClickTime'.
-- 
-- /Since: 0.4/
backendGetDoubleClickTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> m Word32
    -- ^ __Returns:__ a time in milliseconds
backendGetDoubleClickTime :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> m Word32
backendGetDoubleClickTime a
backend = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    Word32
result <- Ptr Backend -> IO Word32
clutter_backend_get_double_click_time Ptr Backend
backend'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data BackendGetDoubleClickTimeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsBackend a) => O.OverloadedMethod BackendGetDoubleClickTimeMethodInfo a signature where
    overloadedMethod = backendGetDoubleClickTime

instance O.OverloadedMethodInfo BackendGetDoubleClickTimeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendGetDoubleClickTime",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendGetDoubleClickTime"
        })


#endif

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

foreign import ccall "clutter_backend_get_font_name" clutter_backend_get_font_name :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    IO CString

{-# DEPRECATED backendGetFontName ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/font-name/@ instead"] #-}
-- | Retrieves the default font name as set by
-- 'GI.Clutter.Objects.Backend.backendSetFontName'.
-- 
-- /Since: 1.0/
backendGetFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> m T.Text
    -- ^ __Returns:__ the font name for the backend. The returned string is
    --   owned by the t'GI.Clutter.Objects.Backend.Backend' and should never be modified or freed
backendGetFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> m Text
backendGetFontName a
backend = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    CString
result <- Ptr Backend -> IO CString
clutter_backend_get_font_name Ptr Backend
backend'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"backendGetFontName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data BackendGetFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsBackend a) => O.OverloadedMethod BackendGetFontNameMethodInfo a signature where
    overloadedMethod = backendGetFontName

instance O.OverloadedMethodInfo BackendGetFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendGetFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendGetFontName"
        })


#endif

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

foreign import ccall "clutter_backend_get_font_options" clutter_backend_get_font_options :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    IO (Ptr Cairo.FontOptions.FontOptions)

-- | Retrieves the font options for /@backend@/.
-- 
-- /Since: 0.8/
backendGetFontOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> m Cairo.FontOptions.FontOptions
    -- ^ __Returns:__ the font options of the t'GI.Clutter.Objects.Backend.Backend'.
    --   The returned t'GI.Cairo.Structs.FontOptions.FontOptions' is owned by the backend and should
    --   not be modified or freed
backendGetFontOptions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> m FontOptions
backendGetFontOptions a
backend = IO FontOptions -> m FontOptions
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontOptions -> m FontOptions)
-> IO FontOptions -> m FontOptions
forall a b. (a -> b) -> a -> b
$ do
    Ptr Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    Ptr FontOptions
result <- Ptr Backend -> IO (Ptr FontOptions)
clutter_backend_get_font_options Ptr Backend
backend'
    Text -> Ptr FontOptions -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"backendGetFontOptions" Ptr FontOptions
result
    FontOptions
result' <- ((ManagedPtr FontOptions -> FontOptions)
-> Ptr FontOptions -> IO FontOptions
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr FontOptions -> FontOptions
Cairo.FontOptions.FontOptions) Ptr FontOptions
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    FontOptions -> IO FontOptions
forall (m :: * -> *) a. Monad m => a -> m a
return FontOptions
result'

#if defined(ENABLE_OVERLOADING)
data BackendGetFontOptionsMethodInfo
instance (signature ~ (m Cairo.FontOptions.FontOptions), MonadIO m, IsBackend a) => O.OverloadedMethod BackendGetFontOptionsMethodInfo a signature where
    overloadedMethod = backendGetFontOptions

instance O.OverloadedMethodInfo BackendGetFontOptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendGetFontOptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendGetFontOptions"
        })


#endif

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

foreign import ccall "clutter_backend_get_resolution" clutter_backend_get_resolution :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    IO CDouble

-- | Gets the resolution for font handling on the screen.
-- 
-- The resolution is a scale factor between points specified in a
-- t'GI.Pango.Structs.FontDescription.FontDescription' and cairo units. The default value is 96.0,
-- meaning that a 10 point font will be 13 units
-- high (10 * 96. \/ 72. = 13.3).
-- 
-- Clutter will set the resolution using the current backend when
-- initializing; the resolution is also stored in the
-- t'GI.Clutter.Objects.Settings.Settings':@/font-dpi/@ property.
-- 
-- /Since: 0.4/
backendGetResolution ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> m Double
    -- ^ __Returns:__ the current resolution, or -1 if no resolution
    --   has been set.
backendGetResolution :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> m Double
backendGetResolution a
backend = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    CDouble
result <- Ptr Backend -> IO CDouble
clutter_backend_get_resolution Ptr Backend
backend'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data BackendGetResolutionMethodInfo
instance (signature ~ (m Double), MonadIO m, IsBackend a) => O.OverloadedMethod BackendGetResolutionMethodInfo a signature where
    overloadedMethod = backendGetResolution

instance O.OverloadedMethodInfo BackendGetResolutionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendGetResolution",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendGetResolution"
        })


#endif

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

foreign import ccall "clutter_backend_set_double_click_distance" clutter_backend_set_double_click_distance :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    Word32 ->                               -- distance : TBasicType TUInt
    IO ()

{-# DEPRECATED backendSetDoubleClickDistance ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-distance/@ instead"] #-}
-- | Sets the maximum distance used to verify a double click event.
-- 
-- /Since: 0.4/
backendSetDoubleClickDistance ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> Word32
    -- ^ /@distance@/: a distance, in pixels
    -> m ()
backendSetDoubleClickDistance :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> Word32 -> m ()
backendSetDoubleClickDistance a
backend Word32
distance = 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 Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    Ptr Backend -> Word32 -> IO ()
clutter_backend_set_double_click_distance Ptr Backend
backend' Word32
distance
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BackendSetDoubleClickDistanceMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsBackend a) => O.OverloadedMethod BackendSetDoubleClickDistanceMethodInfo a signature where
    overloadedMethod = backendSetDoubleClickDistance

instance O.OverloadedMethodInfo BackendSetDoubleClickDistanceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendSetDoubleClickDistance",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendSetDoubleClickDistance"
        })


#endif

-- method Backend::set_double_click_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "backend"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Backend" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBackend" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msec"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "milliseconds between two button press events"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_backend_set_double_click_time" clutter_backend_set_double_click_time :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    Word32 ->                               -- msec : TBasicType TUInt
    IO ()

{-# DEPRECATED backendSetDoubleClickTime ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-time/@ instead"] #-}
-- | Sets the maximum time between two button press events, used to
-- verify whether it\'s a double click event or not.
-- 
-- /Since: 0.4/
backendSetDoubleClickTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> Word32
    -- ^ /@msec@/: milliseconds between two button press events
    -> m ()
backendSetDoubleClickTime :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> Word32 -> m ()
backendSetDoubleClickTime a
backend Word32
msec = 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 Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    Ptr Backend -> Word32 -> IO ()
clutter_backend_set_double_click_time Ptr Backend
backend' Word32
msec
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BackendSetDoubleClickTimeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsBackend a) => O.OverloadedMethod BackendSetDoubleClickTimeMethodInfo a signature where
    overloadedMethod = backendSetDoubleClickTime

instance O.OverloadedMethodInfo BackendSetDoubleClickTimeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendSetDoubleClickTime",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendSetDoubleClickTime"
        })


#endif

-- method Backend::set_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "backend"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Backend" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBackend" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the font"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_backend_set_font_name" clutter_backend_set_font_name :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    CString ->                              -- font_name : TBasicType TUTF8
    IO ()

{-# DEPRECATED backendSetFontName ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/font-name/@ instead"] #-}
-- | Sets the default font to be used by Clutter. The /@fontName@/ string
-- must either be 'P.Nothing', which means that the font name from the
-- default t'GI.Clutter.Objects.Backend.Backend' will be used; or be something that can
-- be parsed by the 'GI.Pango.Functions.fontDescriptionFromString' function.
-- 
-- /Since: 1.0/
backendSetFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> T.Text
    -- ^ /@fontName@/: the name of the font
    -> m ()
backendSetFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> Text -> m ()
backendSetFontName a
backend Text
fontName = 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 Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    CString
fontName' <- Text -> IO CString
textToCString Text
fontName
    Ptr Backend -> CString -> IO ()
clutter_backend_set_font_name Ptr Backend
backend' CString
fontName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
fontName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BackendSetFontNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsBackend a) => O.OverloadedMethod BackendSetFontNameMethodInfo a signature where
    overloadedMethod = backendSetFontName

instance O.OverloadedMethodInfo BackendSetFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendSetFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendSetFontName"
        })


#endif

-- method Backend::set_font_options
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "backend"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Backend" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterBackend" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "cairo" , name = "FontOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Cairo font options for the backend, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_backend_set_font_options" clutter_backend_set_font_options :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    Ptr Cairo.FontOptions.FontOptions ->    -- options : TInterface (Name {namespace = "cairo", name = "FontOptions"})
    IO ()

-- | Sets the new font options for /@backend@/. The t'GI.Clutter.Objects.Backend.Backend' will
-- copy the t'GI.Cairo.Structs.FontOptions.FontOptions'.
-- 
-- If /@options@/ is 'P.Nothing', the first following call to
-- 'GI.Clutter.Objects.Backend.backendGetFontOptions' will return the default font
-- options for /@backend@/.
-- 
-- This function is intended for actors creating a Pango layout
-- using the PangoCairo API.
-- 
-- /Since: 0.8/
backendSetFontOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> Cairo.FontOptions.FontOptions
    -- ^ /@options@/: Cairo font options for the backend, or 'P.Nothing'
    -> m ()
backendSetFontOptions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> FontOptions -> m ()
backendSetFontOptions a
backend FontOptions
options = 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 Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    Ptr FontOptions
options' <- FontOptions -> IO (Ptr FontOptions)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FontOptions
options
    Ptr Backend -> Ptr FontOptions -> IO ()
clutter_backend_set_font_options Ptr Backend
backend' Ptr FontOptions
options'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    FontOptions -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr FontOptions
options
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BackendSetFontOptionsMethodInfo
instance (signature ~ (Cairo.FontOptions.FontOptions -> m ()), MonadIO m, IsBackend a) => O.OverloadedMethod BackendSetFontOptionsMethodInfo a signature where
    overloadedMethod = backendSetFontOptions

instance O.OverloadedMethodInfo BackendSetFontOptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendSetFontOptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendSetFontOptions"
        })


#endif

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

foreign import ccall "clutter_backend_set_resolution" clutter_backend_set_resolution :: 
    Ptr Backend ->                          -- backend : TInterface (Name {namespace = "Clutter", name = "Backend"})
    CDouble ->                              -- dpi : TBasicType TDouble
    IO ()

{-# DEPRECATED backendSetResolution ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/font-dpi/@ instead"] #-}
-- | Sets the resolution for font handling on the screen. This is a
-- scale factor between points specified in a t'GI.Pango.Structs.FontDescription.FontDescription'
-- and cairo units. The default value is 96, meaning that a 10 point
-- font will be 13 units high. (10 * 96. \/ 72. = 13.3).
-- 
-- Applications should never need to call this function.
-- 
-- /Since: 0.4/
backendSetResolution ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
    a
    -- ^ /@backend@/: a t'GI.Clutter.Objects.Backend.Backend'
    -> Double
    -- ^ /@dpi@/: the resolution in \"dots per inch\" (Physical inches aren\'t
    --   actually involved; the terminology is conventional).
    -> m ()
backendSetResolution :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBackend a) =>
a -> Double -> m ()
backendSetResolution a
backend Double
dpi = 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 Backend
backend' <- a -> IO (Ptr Backend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
    let dpi' :: CDouble
dpi' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
dpi
    Ptr Backend -> CDouble -> IO ()
clutter_backend_set_resolution Ptr Backend
backend' CDouble
dpi'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backend
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BackendSetResolutionMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsBackend a) => O.OverloadedMethod BackendSetResolutionMethodInfo a signature where
    overloadedMethod = backendSetResolution

instance O.OverloadedMethodInfo BackendSetResolutionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Backend.backendSetResolution",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Backend.html#v:backendSetResolution"
        })


#endif