{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.Alpha
(
Alpha(..) ,
IsAlpha ,
toAlpha ,
#if defined(ENABLE_OVERLOADING)
ResolveAlphaMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
AlphaGetAlphaMethodInfo ,
#endif
alphaGetAlpha ,
#if defined(ENABLE_OVERLOADING)
AlphaGetModeMethodInfo ,
#endif
alphaGetMode ,
#if defined(ENABLE_OVERLOADING)
AlphaGetTimelineMethodInfo ,
#endif
alphaGetTimeline ,
alphaNew ,
alphaNewFull ,
alphaNewWithFunc ,
alphaRegisterFunc ,
#if defined(ENABLE_OVERLOADING)
AlphaSetClosureMethodInfo ,
#endif
alphaSetClosure ,
#if defined(ENABLE_OVERLOADING)
AlphaSetFuncMethodInfo ,
#endif
alphaSetFunc ,
#if defined(ENABLE_OVERLOADING)
AlphaSetModeMethodInfo ,
#endif
alphaSetMode ,
#if defined(ENABLE_OVERLOADING)
AlphaSetTimelineMethodInfo ,
#endif
alphaSetTimeline ,
#if defined(ENABLE_OVERLOADING)
AlphaAlphaPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
alphaAlpha ,
#endif
getAlphaAlpha ,
#if defined(ENABLE_OVERLOADING)
AlphaModePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
alphaMode ,
#endif
constructAlphaMode ,
getAlphaMode ,
setAlphaMode ,
#if defined(ENABLE_OVERLOADING)
AlphaTimelinePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
alphaTimeline ,
#endif
constructAlphaTimeline ,
getAlphaTimeline ,
setAlphaTimeline ,
) 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.GHashTable as B.GHT
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.Kind as DK
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.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
newtype Alpha = Alpha (SP.ManagedPtr Alpha)
deriving (Alpha -> Alpha -> Bool
(Alpha -> Alpha -> Bool) -> (Alpha -> Alpha -> Bool) -> Eq Alpha
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Alpha -> Alpha -> Bool
== :: Alpha -> Alpha -> Bool
$c/= :: Alpha -> Alpha -> Bool
/= :: Alpha -> Alpha -> Bool
Eq)
instance SP.ManagedPtrNewtype Alpha where
toManagedPtr :: Alpha -> ManagedPtr Alpha
toManagedPtr (Alpha ManagedPtr Alpha
p) = ManagedPtr Alpha
p
foreign import ccall "clutter_alpha_get_type"
c_clutter_alpha_get_type :: IO B.Types.GType
instance B.Types.TypedObject Alpha where
glibType :: IO GType
glibType = IO GType
c_clutter_alpha_get_type
instance B.Types.GObject Alpha
class (SP.GObject o, O.IsDescendantOf Alpha o) => IsAlpha o
instance (SP.GObject o, O.IsDescendantOf Alpha o) => IsAlpha o
instance O.HasParentTypes Alpha
type instance O.ParentTypes Alpha = '[GObject.Object.Object, Clutter.Scriptable.Scriptable]
toAlpha :: (MIO.MonadIO m, IsAlpha o) => o -> m Alpha
toAlpha :: forall (m :: * -> *) o. (MonadIO m, IsAlpha o) => o -> m Alpha
toAlpha = IO Alpha -> m Alpha
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Alpha -> m Alpha) -> (o -> IO Alpha) -> o -> m Alpha
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Alpha -> Alpha) -> o -> IO Alpha
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Alpha -> Alpha
Alpha
instance B.GValue.IsGValue (Maybe Alpha) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_alpha_get_type
gvalueSet_ :: Ptr GValue -> Maybe Alpha -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Alpha
P.Nothing = Ptr GValue -> Ptr Alpha -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Alpha
forall a. Ptr a
FP.nullPtr :: FP.Ptr Alpha)
gvalueSet_ Ptr GValue
gv (P.Just Alpha
obj) = Alpha -> (Ptr Alpha -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Alpha
obj (Ptr GValue -> Ptr Alpha -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Alpha)
gvalueGet_ Ptr GValue
gv = do
Ptr Alpha
ptr <- Ptr GValue -> IO (Ptr Alpha)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Alpha)
if Ptr Alpha
ptr Ptr Alpha -> Ptr Alpha -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Alpha
forall a. Ptr a
FP.nullPtr
then Alpha -> Maybe Alpha
forall a. a -> Maybe a
P.Just (Alpha -> Maybe Alpha) -> IO Alpha -> IO (Maybe Alpha)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Alpha -> Alpha) -> Ptr Alpha -> IO Alpha
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Alpha -> Alpha
Alpha Ptr Alpha
ptr
else Maybe Alpha -> IO (Maybe Alpha)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Alpha
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveAlphaMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveAlphaMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveAlphaMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveAlphaMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveAlphaMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveAlphaMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveAlphaMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveAlphaMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveAlphaMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveAlphaMethod "parseCustomNode" o = Clutter.Scriptable.ScriptableParseCustomNodeMethodInfo
ResolveAlphaMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveAlphaMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveAlphaMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveAlphaMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveAlphaMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveAlphaMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveAlphaMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveAlphaMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveAlphaMethod "getAlpha" o = AlphaGetAlphaMethodInfo
ResolveAlphaMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveAlphaMethod "getId" o = Clutter.Scriptable.ScriptableGetIdMethodInfo
ResolveAlphaMethod "getMode" o = AlphaGetModeMethodInfo
ResolveAlphaMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveAlphaMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveAlphaMethod "getTimeline" o = AlphaGetTimelineMethodInfo
ResolveAlphaMethod "setClosure" o = AlphaSetClosureMethodInfo
ResolveAlphaMethod "setCustomProperty" o = Clutter.Scriptable.ScriptableSetCustomPropertyMethodInfo
ResolveAlphaMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveAlphaMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveAlphaMethod "setFunc" o = AlphaSetFuncMethodInfo
ResolveAlphaMethod "setId" o = Clutter.Scriptable.ScriptableSetIdMethodInfo
ResolveAlphaMethod "setMode" o = AlphaSetModeMethodInfo
ResolveAlphaMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveAlphaMethod "setTimeline" o = AlphaSetTimelineMethodInfo
ResolveAlphaMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAlphaMethod t Alpha, O.OverloadedMethod info Alpha p) => OL.IsLabel t (Alpha -> 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 ~ ResolveAlphaMethod t Alpha, O.OverloadedMethod info Alpha p, R.HasField t Alpha p) => R.HasField t Alpha p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAlphaMethod t Alpha, O.OverloadedMethodInfo info Alpha) => OL.IsLabel t (O.MethodProxy info Alpha) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getAlphaAlpha :: (MonadIO m, IsAlpha o) => o -> m Double
getAlphaAlpha :: forall (m :: * -> *) o. (MonadIO m, IsAlpha o) => o -> m Double
getAlphaAlpha o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"alpha"
#if defined(ENABLE_OVERLOADING)
data AlphaAlphaPropertyInfo
instance AttrInfo AlphaAlphaPropertyInfo where
type AttrAllowedOps AlphaAlphaPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint AlphaAlphaPropertyInfo = IsAlpha
type AttrSetTypeConstraint AlphaAlphaPropertyInfo = (~) ()
type AttrTransferTypeConstraint AlphaAlphaPropertyInfo = (~) ()
type AttrTransferType AlphaAlphaPropertyInfo = ()
type AttrGetType AlphaAlphaPropertyInfo = Double
type AttrLabel AlphaAlphaPropertyInfo = "alpha"
type AttrOrigin AlphaAlphaPropertyInfo = Alpha
attrGet = getAlphaAlpha
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alpha"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#g:attr:alpha"
})
#endif
getAlphaMode :: (MonadIO m, IsAlpha o) => o -> m CULong
getAlphaMode :: forall (m :: * -> *) o. (MonadIO m, IsAlpha o) => o -> m CULong
getAlphaMode o
obj = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ o -> String -> IO CULong
forall a. GObject a => a -> String -> IO CULong
B.Properties.getObjectPropertyULong o
obj String
"mode"
setAlphaMode :: (MonadIO m, IsAlpha o) => o -> CULong -> m ()
setAlphaMode :: forall (m :: * -> *) o.
(MonadIO m, IsAlpha o) =>
o -> CULong -> m ()
setAlphaMode o
obj CULong
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> CULong -> IO ()
forall a. GObject a => a -> String -> CULong -> IO ()
B.Properties.setObjectPropertyULong o
obj String
"mode" CULong
val
constructAlphaMode :: (IsAlpha o, MIO.MonadIO m) => CULong -> m (GValueConstruct o)
constructAlphaMode :: forall o (m :: * -> *).
(IsAlpha o, MonadIO m) =>
CULong -> m (GValueConstruct o)
constructAlphaMode CULong
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> CULong -> IO (GValueConstruct o)
forall o. String -> CULong -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyULong String
"mode" CULong
val
#if defined(ENABLE_OVERLOADING)
data AlphaModePropertyInfo
instance AttrInfo AlphaModePropertyInfo where
type AttrAllowedOps AlphaModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint AlphaModePropertyInfo = IsAlpha
type AttrSetTypeConstraint AlphaModePropertyInfo = (~) CULong
type AttrTransferTypeConstraint AlphaModePropertyInfo = (~) CULong
type AttrTransferType AlphaModePropertyInfo = CULong
type AttrGetType AlphaModePropertyInfo = CULong
type AttrLabel AlphaModePropertyInfo = "mode"
type AttrOrigin AlphaModePropertyInfo = Alpha
attrGet = getAlphaMode
attrSet = setAlphaMode
attrTransfer _ v = do
return v
attrConstruct = constructAlphaMode
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.mode"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#g:attr:mode"
})
#endif
getAlphaTimeline :: (MonadIO m, IsAlpha o) => o -> m Clutter.Timeline.Timeline
getAlphaTimeline :: forall (m :: * -> *) o. (MonadIO m, IsAlpha o) => o -> m Timeline
getAlphaTimeline o
obj = IO Timeline -> m Timeline
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Timeline -> m Timeline) -> IO Timeline -> m Timeline
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Timeline) -> IO Timeline
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getAlphaTimeline" (IO (Maybe Timeline) -> IO Timeline)
-> IO (Maybe Timeline) -> IO Timeline
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Timeline -> Timeline)
-> IO (Maybe Timeline)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"timeline" ManagedPtr Timeline -> Timeline
Clutter.Timeline.Timeline
setAlphaTimeline :: (MonadIO m, IsAlpha o, Clutter.Timeline.IsTimeline a) => o -> a -> m ()
setAlphaTimeline :: forall (m :: * -> *) o a.
(MonadIO m, IsAlpha o, IsTimeline a) =>
o -> a -> m ()
setAlphaTimeline o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"timeline" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)
constructAlphaTimeline :: (IsAlpha o, MIO.MonadIO m, Clutter.Timeline.IsTimeline a) => a -> m (GValueConstruct o)
constructAlphaTimeline :: forall o (m :: * -> *) a.
(IsAlpha o, MonadIO m, IsTimeline a) =>
a -> m (GValueConstruct o)
constructAlphaTimeline a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"timeline" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data AlphaTimelinePropertyInfo
instance AttrInfo AlphaTimelinePropertyInfo where
type AttrAllowedOps AlphaTimelinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint AlphaTimelinePropertyInfo = IsAlpha
type AttrSetTypeConstraint AlphaTimelinePropertyInfo = Clutter.Timeline.IsTimeline
type AttrTransferTypeConstraint AlphaTimelinePropertyInfo = Clutter.Timeline.IsTimeline
type AttrTransferType AlphaTimelinePropertyInfo = Clutter.Timeline.Timeline
type AttrGetType AlphaTimelinePropertyInfo = Clutter.Timeline.Timeline
type AttrLabel AlphaTimelinePropertyInfo = "timeline"
type AttrOrigin AlphaTimelinePropertyInfo = Alpha
attrGet = getAlphaTimeline
attrSet = setAlphaTimeline
attrTransfer _ v = do
unsafeCastTo Clutter.Timeline.Timeline v
attrConstruct = constructAlphaTimeline
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.timeline"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#g:attr:timeline"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Alpha
type instance O.AttributeList Alpha = AlphaAttributeList
type AlphaAttributeList = ('[ '("alpha", AlphaAlphaPropertyInfo), '("mode", AlphaModePropertyInfo), '("timeline", AlphaTimelinePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
alphaAlpha :: AttrLabelProxy "alpha"
alphaAlpha = AttrLabelProxy
alphaMode :: AttrLabelProxy "mode"
alphaMode = AttrLabelProxy
alphaTimeline :: AttrLabelProxy "timeline"
alphaTimeline = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Alpha = AlphaSignalList
type AlphaSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_alpha_new" clutter_alpha_new ::
IO (Ptr Alpha)
{-# DEPRECATED alphaNew ["(Since version 1.12)","Use t'GI.Clutter.Objects.Timeline.Timeline' instead"] #-}
alphaNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Alpha
alphaNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Alpha
alphaNew = IO Alpha -> m Alpha
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Alpha -> m Alpha) -> IO Alpha -> m Alpha
forall a b. (a -> b) -> a -> b
$ do
Ptr Alpha
result <- IO (Ptr Alpha)
clutter_alpha_new
Text -> Ptr Alpha -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"alphaNew" Ptr Alpha
result
Alpha
result' <- ((ManagedPtr Alpha -> Alpha) -> Ptr Alpha -> IO Alpha
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Alpha -> Alpha
Alpha) Ptr Alpha
result
Alpha -> IO Alpha
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Alpha
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_alpha_new_full" clutter_alpha_new_full ::
Ptr Clutter.Timeline.Timeline ->
CULong ->
IO (Ptr Alpha)
{-# DEPRECATED alphaNewFull ["(Since version 1.12)","Use t'GI.Clutter.Objects.Timeline.Timeline' instead"] #-}
alphaNewFull ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.Timeline.IsTimeline a) =>
a
-> CULong
-> m Alpha
alphaNewFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimeline a) =>
a -> CULong -> m Alpha
alphaNewFull a
timeline CULong
mode = IO Alpha -> m Alpha
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Alpha -> m Alpha) -> IO Alpha -> m Alpha
forall a b. (a -> b) -> a -> b
$ do
Ptr Timeline
timeline' <- a -> IO (Ptr Timeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
timeline
Ptr Alpha
result <- Ptr Timeline -> CULong -> IO (Ptr Alpha)
clutter_alpha_new_full Ptr Timeline
timeline' CULong
mode
Text -> Ptr Alpha -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"alphaNewFull" Ptr Alpha
result
Alpha
result' <- ((ManagedPtr Alpha -> Alpha) -> Ptr Alpha -> IO Alpha
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Alpha -> Alpha
Alpha) Ptr Alpha
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
timeline
Alpha -> IO Alpha
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Alpha
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_alpha_new_with_func" clutter_alpha_new_with_func ::
Ptr Clutter.Timeline.Timeline ->
FunPtr Clutter.Callbacks.C_AlphaFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr Alpha)
{-# DEPRECATED alphaNewWithFunc ["(Since version 1.12)","Use t'GI.Clutter.Objects.Timeline.Timeline' instead"] #-}
alphaNewWithFunc ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.Timeline.IsTimeline a) =>
a
-> Clutter.Callbacks.AlphaFunc
-> m Alpha
alphaNewWithFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimeline a) =>
a -> AlphaFunc -> m Alpha
alphaNewWithFunc a
timeline AlphaFunc
func = IO Alpha -> m Alpha
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Alpha -> m Alpha) -> IO Alpha -> m Alpha
forall a b. (a -> b) -> a -> b
$ do
Ptr Timeline
timeline' <- a -> IO (Ptr Timeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
timeline
FunPtr C_AlphaFunc
func' <- C_AlphaFunc -> IO (FunPtr C_AlphaFunc)
Clutter.Callbacks.mk_AlphaFunc (Maybe (Ptr (FunPtr C_AlphaFunc))
-> AlphaFunc_WithClosures -> C_AlphaFunc
Clutter.Callbacks.wrap_AlphaFunc Maybe (Ptr (FunPtr C_AlphaFunc))
forall a. Maybe a
Nothing (AlphaFunc -> AlphaFunc_WithClosures
Clutter.Callbacks.drop_closures_AlphaFunc AlphaFunc
func))
let data_ :: Ptr ()
data_ = FunPtr C_AlphaFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_AlphaFunc
func'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Alpha
result <- Ptr Timeline
-> FunPtr C_AlphaFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO (Ptr Alpha)
clutter_alpha_new_with_func Ptr Timeline
timeline' FunPtr C_AlphaFunc
func' Ptr ()
data_ FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroy
Text -> Ptr Alpha -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"alphaNewWithFunc" Ptr Alpha
result
Alpha
result' <- ((ManagedPtr Alpha -> Alpha) -> Ptr Alpha -> IO Alpha
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Alpha -> Alpha
Alpha) Ptr Alpha
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
timeline
Alpha -> IO Alpha
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Alpha
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_alpha_get_alpha" clutter_alpha_get_alpha ::
Ptr Alpha ->
IO CDouble
{-# DEPRECATED alphaGetAlpha ["(Since version 1.12)","Use 'GI.Clutter.Objects.Timeline.timelineGetProgress'"] #-}
alphaGetAlpha ::
(B.CallStack.HasCallStack, MonadIO m, IsAlpha a) =>
a
-> m Double
alphaGetAlpha :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAlpha a) =>
a -> m Double
alphaGetAlpha a
alpha = IO Double -> m Double
forall a. IO a -> m a
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 Alpha
alpha' <- a -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
alpha
CDouble
result <- Ptr Alpha -> IO CDouble
clutter_alpha_get_alpha Ptr Alpha
alpha'
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
alpha
Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'
#if defined(ENABLE_OVERLOADING)
data AlphaGetAlphaMethodInfo
instance (signature ~ (m Double), MonadIO m, IsAlpha a) => O.OverloadedMethod AlphaGetAlphaMethodInfo a signature where
overloadedMethod = alphaGetAlpha
instance O.OverloadedMethodInfo AlphaGetAlphaMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alphaGetAlpha",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#v:alphaGetAlpha"
})
#endif
foreign import ccall "clutter_alpha_get_mode" clutter_alpha_get_mode ::
Ptr Alpha ->
IO CULong
{-# DEPRECATED alphaGetMode ["(Since version 1.12)","Use t'GI.Clutter.Objects.Timeline.Timeline' instead"] #-}
alphaGetMode ::
(B.CallStack.HasCallStack, MonadIO m, IsAlpha a) =>
a
-> m CULong
alphaGetMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAlpha a) =>
a -> m CULong
alphaGetMode a
alpha = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ do
Ptr Alpha
alpha' <- a -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
alpha
CULong
result <- Ptr Alpha -> IO CULong
clutter_alpha_get_mode Ptr Alpha
alpha'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
alpha
CULong -> IO CULong
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
result
#if defined(ENABLE_OVERLOADING)
data AlphaGetModeMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsAlpha a) => O.OverloadedMethod AlphaGetModeMethodInfo a signature where
overloadedMethod = alphaGetMode
instance O.OverloadedMethodInfo AlphaGetModeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alphaGetMode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#v:alphaGetMode"
})
#endif
foreign import ccall "clutter_alpha_get_timeline" clutter_alpha_get_timeline ::
Ptr Alpha ->
IO (Ptr Clutter.Timeline.Timeline)
{-# DEPRECATED alphaGetTimeline ["(Since version 1.12)","Use t'GI.Clutter.Objects.Timeline.Timeline' directlry"] #-}
alphaGetTimeline ::
(B.CallStack.HasCallStack, MonadIO m, IsAlpha a) =>
a
-> m Clutter.Timeline.Timeline
alphaGetTimeline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAlpha a) =>
a -> m Timeline
alphaGetTimeline a
alpha = IO Timeline -> m Timeline
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Timeline -> m Timeline) -> IO Timeline -> m Timeline
forall a b. (a -> b) -> a -> b
$ do
Ptr Alpha
alpha' <- a -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
alpha
Ptr Timeline
result <- Ptr Alpha -> IO (Ptr Timeline)
clutter_alpha_get_timeline Ptr Alpha
alpha'
Text -> Ptr Timeline -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"alphaGetTimeline" Ptr Timeline
result
Timeline
result' <- ((ManagedPtr Timeline -> Timeline) -> Ptr Timeline -> IO Timeline
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Timeline -> Timeline
Clutter.Timeline.Timeline) Ptr Timeline
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
alpha
Timeline -> IO Timeline
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Timeline
result'
#if defined(ENABLE_OVERLOADING)
data AlphaGetTimelineMethodInfo
instance (signature ~ (m Clutter.Timeline.Timeline), MonadIO m, IsAlpha a) => O.OverloadedMethod AlphaGetTimelineMethodInfo a signature where
overloadedMethod = alphaGetTimeline
instance O.OverloadedMethodInfo AlphaGetTimelineMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alphaGetTimeline",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#v:alphaGetTimeline"
})
#endif
foreign import ccall "clutter_alpha_set_closure" clutter_alpha_set_closure ::
Ptr Alpha ->
Ptr (GClosure ()) ->
IO ()
{-# DEPRECATED alphaSetClosure ["(Since version 1.12)","Use 'GI.Clutter.Objects.Timeline.timelineSetProgressFunc'"] #-}
alphaSetClosure ::
(B.CallStack.HasCallStack, MonadIO m, IsAlpha a) =>
a
-> GClosure b
-> m ()
alphaSetClosure :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAlpha a) =>
a -> GClosure b -> m ()
alphaSetClosure a
alpha GClosure b
closure = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Alpha
alpha' <- a -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
alpha
Ptr (GClosure ())
closure' <- GClosure b -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure b
closure
Ptr Alpha -> Ptr (GClosure ()) -> IO ()
clutter_alpha_set_closure Ptr Alpha
alpha' Ptr (GClosure ())
closure'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
alpha
GClosure b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure b
closure
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AlphaSetClosureMethodInfo
instance (signature ~ (GClosure b -> m ()), MonadIO m, IsAlpha a) => O.OverloadedMethod AlphaSetClosureMethodInfo a signature where
overloadedMethod = alphaSetClosure
instance O.OverloadedMethodInfo AlphaSetClosureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alphaSetClosure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#v:alphaSetClosure"
})
#endif
foreign import ccall "clutter_alpha_set_func" clutter_alpha_set_func ::
Ptr Alpha ->
FunPtr Clutter.Callbacks.C_AlphaFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
{-# DEPRECATED alphaSetFunc ["(Since version 1.12)","Use 'GI.Clutter.Objects.Timeline.timelineSetProgressFunc'"] #-}
alphaSetFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsAlpha a) =>
a
-> Clutter.Callbacks.AlphaFunc
-> m ()
alphaSetFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAlpha a) =>
a -> AlphaFunc -> m ()
alphaSetFunc a
alpha AlphaFunc
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Alpha
alpha' <- a -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
alpha
FunPtr C_AlphaFunc
func' <- C_AlphaFunc -> IO (FunPtr C_AlphaFunc)
Clutter.Callbacks.mk_AlphaFunc (Maybe (Ptr (FunPtr C_AlphaFunc))
-> AlphaFunc_WithClosures -> C_AlphaFunc
Clutter.Callbacks.wrap_AlphaFunc Maybe (Ptr (FunPtr C_AlphaFunc))
forall a. Maybe a
Nothing (AlphaFunc -> AlphaFunc_WithClosures
Clutter.Callbacks.drop_closures_AlphaFunc AlphaFunc
func))
let data_ :: Ptr ()
data_ = FunPtr C_AlphaFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_AlphaFunc
func'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Alpha
-> FunPtr C_AlphaFunc -> Ptr () -> FunPtr C_DestroyNotify -> IO ()
clutter_alpha_set_func Ptr Alpha
alpha' FunPtr C_AlphaFunc
func' Ptr ()
data_ FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroy
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
alpha
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AlphaSetFuncMethodInfo
instance (signature ~ (Clutter.Callbacks.AlphaFunc -> m ()), MonadIO m, IsAlpha a) => O.OverloadedMethod AlphaSetFuncMethodInfo a signature where
overloadedMethod = alphaSetFunc
instance O.OverloadedMethodInfo AlphaSetFuncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alphaSetFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#v:alphaSetFunc"
})
#endif
foreign import ccall "clutter_alpha_set_mode" clutter_alpha_set_mode ::
Ptr Alpha ->
CULong ->
IO ()
{-# DEPRECATED alphaSetMode ["(Since version 1.12)","Use t'GI.Clutter.Objects.Timeline.Timeline' and"," 'GI.Clutter.Objects.Timeline.timelineSetProgressMode' instead"] #-}
alphaSetMode ::
(B.CallStack.HasCallStack, MonadIO m, IsAlpha a) =>
a
-> CULong
-> m ()
alphaSetMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAlpha a) =>
a -> CULong -> m ()
alphaSetMode a
alpha CULong
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Alpha
alpha' <- a -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
alpha
Ptr Alpha -> CULong -> IO ()
clutter_alpha_set_mode Ptr Alpha
alpha' CULong
mode
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
alpha
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AlphaSetModeMethodInfo
instance (signature ~ (CULong -> m ()), MonadIO m, IsAlpha a) => O.OverloadedMethod AlphaSetModeMethodInfo a signature where
overloadedMethod = alphaSetMode
instance O.OverloadedMethodInfo AlphaSetModeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alphaSetMode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#v:alphaSetMode"
})
#endif
foreign import ccall "clutter_alpha_set_timeline" clutter_alpha_set_timeline ::
Ptr Alpha ->
Ptr Clutter.Timeline.Timeline ->
IO ()
{-# DEPRECATED alphaSetTimeline ["(Since version 1.12)","Use t'GI.Clutter.Objects.Timeline.Timeline' directly"] #-}
alphaSetTimeline ::
(B.CallStack.HasCallStack, MonadIO m, IsAlpha a, Clutter.Timeline.IsTimeline b) =>
a
-> b
-> m ()
alphaSetTimeline :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAlpha a, IsTimeline b) =>
a -> b -> m ()
alphaSetTimeline a
alpha b
timeline = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Alpha
alpha' <- a -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
alpha
Ptr Timeline
timeline' <- b -> IO (Ptr Timeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
timeline
Ptr Alpha -> Ptr Timeline -> IO ()
clutter_alpha_set_timeline Ptr Alpha
alpha' Ptr Timeline
timeline'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
alpha
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
timeline
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AlphaSetTimelineMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsAlpha a, Clutter.Timeline.IsTimeline b) => O.OverloadedMethod AlphaSetTimelineMethodInfo a signature where
overloadedMethod = alphaSetTimeline
instance O.OverloadedMethodInfo AlphaSetTimelineMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.Alpha.alphaSetTimeline",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-Alpha.html#v:alphaSetTimeline"
})
#endif
foreign import ccall "clutter_alpha_register_closure" clutter_alpha_register_closure ::
Ptr (GClosure ()) ->
IO CULong
{-# DEPRECATED alphaRegisterFunc ["(Since version 1.12)","There is no direct replacement for this"," function. Use 'GI.Clutter.Objects.Timeline.timelineSetProgressFunc' on each"," specific t'GI.Clutter.Objects.Timeline.Timeline' instance"] #-}
alphaRegisterFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
GClosure a
-> m CULong
alphaRegisterFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m) =>
GClosure a -> m CULong
alphaRegisterFunc GClosure a
closure = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ do
Ptr (GClosure ())
closure' <- GClosure a -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure a
closure
CULong
result <- Ptr (GClosure ()) -> IO CULong
clutter_alpha_register_closure Ptr (GClosure ())
closure'
GClosure a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure a
closure
CULong -> IO CULong
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
result
#if defined(ENABLE_OVERLOADING)
#endif