{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.Backend
(
Backend(..) ,
IsBackend ,
toBackend ,
#if defined(ENABLE_OVERLOADING)
ResolveBackendMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BackendGetDoubleClickDistanceMethodInfo ,
#endif
backendGetDoubleClickDistance ,
#if defined(ENABLE_OVERLOADING)
BackendGetDoubleClickTimeMethodInfo ,
#endif
backendGetDoubleClickTime ,
#if defined(ENABLE_OVERLOADING)
BackendGetFontNameMethodInfo ,
#endif
backendGetFontName ,
#if defined(ENABLE_OVERLOADING)
BackendGetFontOptionsMethodInfo ,
#endif
backendGetFontOptions ,
#if defined(ENABLE_OVERLOADING)
BackendGetResolutionMethodInfo ,
#endif
backendGetResolution ,
#if defined(ENABLE_OVERLOADING)
BackendSetDoubleClickDistanceMethodInfo ,
#endif
backendSetDoubleClickDistance ,
#if defined(ENABLE_OVERLOADING)
BackendSetDoubleClickTimeMethodInfo ,
#endif
backendSetDoubleClickTime ,
#if defined(ENABLE_OVERLOADING)
BackendSetFontNameMethodInfo ,
#endif
backendSetFontName ,
#if defined(ENABLE_OVERLOADING)
BackendSetFontOptionsMethodInfo ,
#endif
backendSetFontOptions ,
#if defined(ENABLE_OVERLOADING)
BackendSetResolutionMethodInfo ,
#endif
backendSetResolution ,
BackendFontChangedCallback ,
#if defined(ENABLE_OVERLOADING)
BackendFontChangedSignalInfo ,
#endif
afterBackendFontChanged ,
onBackendFontChanged ,
BackendResolutionChangedCallback ,
#if defined(ENABLE_OVERLOADING)
BackendResolutionChangedSignalInfo ,
#endif
afterBackendResolutionChanged ,
onBackendResolutionChanged ,
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
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
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]
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
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
type BackendFontChangedCallback =
IO ()
type C_BackendFontChangedCallback =
Ptr Backend ->
Ptr () ->
IO ()
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)
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
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
type BackendResolutionChangedCallback =
IO ()
type C_BackendResolutionChangedCallback =
Ptr Backend ->
Ptr () ->
IO ()
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)
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
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
type BackendSettingsChangedCallback =
IO ()
type C_BackendSettingsChangedCallback =
Ptr Backend ->
Ptr () ->
IO ()
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)
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
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
foreign import ccall "clutter_backend_get_double_click_distance" clutter_backend_get_double_click_distance ::
Ptr Backend ->
IO Word32
{-# DEPRECATED backendGetDoubleClickDistance ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-distance/@ instead"] #-}
backendGetDoubleClickDistance ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> m Word32
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
foreign import ccall "clutter_backend_get_double_click_time" clutter_backend_get_double_click_time ::
Ptr Backend ->
IO Word32
{-# DEPRECATED backendGetDoubleClickTime ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-time/@ instead"] #-}
backendGetDoubleClickTime ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> m Word32
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
foreign import ccall "clutter_backend_get_font_name" clutter_backend_get_font_name ::
Ptr Backend ->
IO CString
{-# DEPRECATED backendGetFontName ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/font-name/@ instead"] #-}
backendGetFontName ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> m T.Text
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
foreign import ccall "clutter_backend_get_font_options" clutter_backend_get_font_options ::
Ptr Backend ->
IO (Ptr Cairo.FontOptions.FontOptions)
backendGetFontOptions ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> m Cairo.FontOptions.FontOptions
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
foreign import ccall "clutter_backend_get_resolution" clutter_backend_get_resolution ::
Ptr Backend ->
IO CDouble
backendGetResolution ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> m Double
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
foreign import ccall "clutter_backend_set_double_click_distance" clutter_backend_set_double_click_distance ::
Ptr Backend ->
Word32 ->
IO ()
{-# DEPRECATED backendSetDoubleClickDistance ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-distance/@ instead"] #-}
backendSetDoubleClickDistance ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> Word32
-> 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
foreign import ccall "clutter_backend_set_double_click_time" clutter_backend_set_double_click_time ::
Ptr Backend ->
Word32 ->
IO ()
{-# DEPRECATED backendSetDoubleClickTime ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/double-click-time/@ instead"] #-}
backendSetDoubleClickTime ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> Word32
-> 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
foreign import ccall "clutter_backend_set_font_name" clutter_backend_set_font_name ::
Ptr Backend ->
CString ->
IO ()
{-# DEPRECATED backendSetFontName ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/font-name/@ instead"] #-}
backendSetFontName ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> T.Text
-> 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
foreign import ccall "clutter_backend_set_font_options" clutter_backend_set_font_options ::
Ptr Backend ->
Ptr Cairo.FontOptions.FontOptions ->
IO ()
backendSetFontOptions ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> Cairo.FontOptions.FontOptions
-> 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
foreign import ccall "clutter_backend_set_resolution" clutter_backend_set_resolution ::
Ptr Backend ->
CDouble ->
IO ()
{-# DEPRECATED backendSetResolution ["(Since version 1.4)","Use t'GI.Clutter.Objects.Settings.Settings':@/font-dpi/@ instead"] #-}
backendSetResolution ::
(B.CallStack.HasCallStack, MonadIO m, IsBackend a) =>
a
-> Double
-> 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