{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Clutter.Objects.PropertyTransition.PropertyTransition' structure contains
-- private data and should only be accessed using the provided API.
-- 
-- /Since: 1.10/

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

module GI.Clutter.Objects.PropertyTransition
    ( 

-- * Exported types
    PropertyTransition(..)                  ,
    IsPropertyTransition                    ,
    toPropertyTransition                    ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addMarker]("GI.Clutter.Objects.Timeline#g:method:addMarker"), [addMarkerAtTime]("GI.Clutter.Objects.Timeline#g:method:addMarkerAtTime"), [advance]("GI.Clutter.Objects.Timeline#g:method:advance"), [advanceToMarker]("GI.Clutter.Objects.Timeline#g:method:advanceToMarker"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clone]("GI.Clutter.Objects.Timeline#g:method:clone"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasMarker]("GI.Clutter.Objects.Timeline#g:method:hasMarker"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isPlaying]("GI.Clutter.Objects.Timeline#g:method:isPlaying"), [listMarkers]("GI.Clutter.Objects.Timeline#g:method:listMarkers"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [parseCustomNode]("GI.Clutter.Interfaces.Scriptable#g:method:parseCustomNode"), [pause]("GI.Clutter.Objects.Timeline#g:method:pause"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeMarker]("GI.Clutter.Objects.Timeline#g:method:removeMarker"), [rewind]("GI.Clutter.Objects.Timeline#g:method:rewind"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [skip]("GI.Clutter.Objects.Timeline#g:method:skip"), [start]("GI.Clutter.Objects.Timeline#g:method:start"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [stop]("GI.Clutter.Objects.Timeline#g:method:stop"), [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
-- [getAnimatable]("GI.Clutter.Objects.Transition#g:method:getAnimatable"), [getAutoReverse]("GI.Clutter.Objects.Timeline#g:method:getAutoReverse"), [getCubicBezierProgress]("GI.Clutter.Objects.Timeline#g:method:getCubicBezierProgress"), [getCurrentRepeat]("GI.Clutter.Objects.Timeline#g:method:getCurrentRepeat"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDelay]("GI.Clutter.Objects.Timeline#g:method:getDelay"), [getDelta]("GI.Clutter.Objects.Timeline#g:method:getDelta"), [getDirection]("GI.Clutter.Objects.Timeline#g:method:getDirection"), [getDuration]("GI.Clutter.Objects.Timeline#g:method:getDuration"), [getDurationHint]("GI.Clutter.Objects.Timeline#g:method:getDurationHint"), [getElapsedTime]("GI.Clutter.Objects.Timeline#g:method:getElapsedTime"), [getId]("GI.Clutter.Interfaces.Scriptable#g:method:getId"), [getInterval]("GI.Clutter.Objects.Transition#g:method:getInterval"), [getLoop]("GI.Clutter.Objects.Timeline#g:method:getLoop"), [getProgress]("GI.Clutter.Objects.Timeline#g:method:getProgress"), [getProgressMode]("GI.Clutter.Objects.Timeline#g:method:getProgressMode"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPropertyName]("GI.Clutter.Objects.PropertyTransition#g:method:getPropertyName"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRemoveOnComplete]("GI.Clutter.Objects.Transition#g:method:getRemoveOnComplete"), [getRepeatCount]("GI.Clutter.Objects.Timeline#g:method:getRepeatCount"), [getStepProgress]("GI.Clutter.Objects.Timeline#g:method:getStepProgress").
-- 
-- ==== Setters
-- [setAnimatable]("GI.Clutter.Objects.Transition#g:method:setAnimatable"), [setAutoReverse]("GI.Clutter.Objects.Timeline#g:method:setAutoReverse"), [setCubicBezierProgress]("GI.Clutter.Objects.Timeline#g:method:setCubicBezierProgress"), [setCustomProperty]("GI.Clutter.Interfaces.Scriptable#g:method:setCustomProperty"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDelay]("GI.Clutter.Objects.Timeline#g:method:setDelay"), [setDirection]("GI.Clutter.Objects.Timeline#g:method:setDirection"), [setDuration]("GI.Clutter.Objects.Timeline#g:method:setDuration"), [setFrom]("GI.Clutter.Objects.Transition#g:method:setFrom"), [setId]("GI.Clutter.Interfaces.Scriptable#g:method:setId"), [setInterval]("GI.Clutter.Objects.Transition#g:method:setInterval"), [setLoop]("GI.Clutter.Objects.Timeline#g:method:setLoop"), [setProgressFunc]("GI.Clutter.Objects.Timeline#g:method:setProgressFunc"), [setProgressMode]("GI.Clutter.Objects.Timeline#g:method:setProgressMode"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPropertyName]("GI.Clutter.Objects.PropertyTransition#g:method:setPropertyName"), [setRemoveOnComplete]("GI.Clutter.Objects.Transition#g:method:setRemoveOnComplete"), [setRepeatCount]("GI.Clutter.Objects.Timeline#g:method:setRepeatCount"), [setStepProgress]("GI.Clutter.Objects.Timeline#g:method:setStepProgress"), [setTo]("GI.Clutter.Objects.Transition#g:method:setTo").

#if defined(ENABLE_OVERLOADING)
    ResolvePropertyTransitionMethod         ,
#endif

-- ** getPropertyName #method:getPropertyName#

#if defined(ENABLE_OVERLOADING)
    PropertyTransitionGetPropertyNameMethodInfo,
#endif
    propertyTransitionGetPropertyName       ,


-- ** new #method:new#

    propertyTransitionNew                   ,


-- ** setPropertyName #method:setPropertyName#

#if defined(ENABLE_OVERLOADING)
    PropertyTransitionSetPropertyNameMethodInfo,
#endif
    propertyTransitionSetPropertyName       ,




 -- * Properties


-- ** propertyName #attr:propertyName#
-- | The name of the property of a t'GI.Clutter.Interfaces.Animatable.Animatable' to animate.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    PropertyTransitionPropertyNamePropertyInfo,
#endif
    clearPropertyTransitionPropertyName     ,
    constructPropertyTransitionPropertyName ,
    getPropertyTransitionPropertyName       ,
#if defined(ENABLE_OVERLOADING)
    propertyTransitionPropertyName          ,
#endif
    setPropertyTransitionPropertyName       ,




    ) 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.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 {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import {-# SOURCE #-} qualified GI.Clutter.Objects.Transition as Clutter.Transition
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "clutter_property_transition_get_type"
    c_clutter_property_transition_get_type :: IO B.Types.GType

instance B.Types.TypedObject PropertyTransition where
    glibType :: IO GType
glibType = IO GType
c_clutter_property_transition_get_type

instance B.Types.GObject PropertyTransition

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

instance O.HasParentTypes PropertyTransition
type instance O.ParentTypes PropertyTransition = '[Clutter.Transition.Transition, Clutter.Timeline.Timeline, GObject.Object.Object, Clutter.Scriptable.Scriptable]

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

-- | Convert 'PropertyTransition' 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 PropertyTransition) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_property_transition_get_type
    gvalueSet_ :: Ptr GValue -> Maybe PropertyTransition -> IO ()
gvalueSet_ Ptr GValue
gv Maybe PropertyTransition
P.Nothing = Ptr GValue -> Ptr PropertyTransition -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr PropertyTransition
forall a. Ptr a
FP.nullPtr :: FP.Ptr PropertyTransition)
    gvalueSet_ Ptr GValue
gv (P.Just PropertyTransition
obj) = PropertyTransition -> (Ptr PropertyTransition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PropertyTransition
obj (Ptr GValue -> Ptr PropertyTransition -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe PropertyTransition)
gvalueGet_ Ptr GValue
gv = do
        Ptr PropertyTransition
ptr <- Ptr GValue -> IO (Ptr PropertyTransition)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr PropertyTransition)
        if Ptr PropertyTransition
ptr Ptr PropertyTransition -> Ptr PropertyTransition -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr PropertyTransition
forall a. Ptr a
FP.nullPtr
        then PropertyTransition -> Maybe PropertyTransition
forall a. a -> Maybe a
P.Just (PropertyTransition -> Maybe PropertyTransition)
-> IO PropertyTransition -> IO (Maybe PropertyTransition)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr PropertyTransition -> PropertyTransition)
-> Ptr PropertyTransition -> IO PropertyTransition
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr PropertyTransition -> PropertyTransition
PropertyTransition Ptr PropertyTransition
ptr
        else Maybe PropertyTransition -> IO (Maybe PropertyTransition)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PropertyTransition
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolvePropertyTransitionMethod (t :: Symbol) (o :: *) :: * where
    ResolvePropertyTransitionMethod "addMarker" o = Clutter.Timeline.TimelineAddMarkerMethodInfo
    ResolvePropertyTransitionMethod "addMarkerAtTime" o = Clutter.Timeline.TimelineAddMarkerAtTimeMethodInfo
    ResolvePropertyTransitionMethod "advance" o = Clutter.Timeline.TimelineAdvanceMethodInfo
    ResolvePropertyTransitionMethod "advanceToMarker" o = Clutter.Timeline.TimelineAdvanceToMarkerMethodInfo
    ResolvePropertyTransitionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolvePropertyTransitionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolvePropertyTransitionMethod "clone" o = Clutter.Timeline.TimelineCloneMethodInfo
    ResolvePropertyTransitionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolvePropertyTransitionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolvePropertyTransitionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolvePropertyTransitionMethod "hasMarker" o = Clutter.Timeline.TimelineHasMarkerMethodInfo
    ResolvePropertyTransitionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolvePropertyTransitionMethod "isPlaying" o = Clutter.Timeline.TimelineIsPlayingMethodInfo
    ResolvePropertyTransitionMethod "listMarkers" o = Clutter.Timeline.TimelineListMarkersMethodInfo
    ResolvePropertyTransitionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolvePropertyTransitionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolvePropertyTransitionMethod "parseCustomNode" o = Clutter.Scriptable.ScriptableParseCustomNodeMethodInfo
    ResolvePropertyTransitionMethod "pause" o = Clutter.Timeline.TimelinePauseMethodInfo
    ResolvePropertyTransitionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolvePropertyTransitionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolvePropertyTransitionMethod "removeMarker" o = Clutter.Timeline.TimelineRemoveMarkerMethodInfo
    ResolvePropertyTransitionMethod "rewind" o = Clutter.Timeline.TimelineRewindMethodInfo
    ResolvePropertyTransitionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolvePropertyTransitionMethod "skip" o = Clutter.Timeline.TimelineSkipMethodInfo
    ResolvePropertyTransitionMethod "start" o = Clutter.Timeline.TimelineStartMethodInfo
    ResolvePropertyTransitionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolvePropertyTransitionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolvePropertyTransitionMethod "stop" o = Clutter.Timeline.TimelineStopMethodInfo
    ResolvePropertyTransitionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolvePropertyTransitionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolvePropertyTransitionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolvePropertyTransitionMethod "getAnimatable" o = Clutter.Transition.TransitionGetAnimatableMethodInfo
    ResolvePropertyTransitionMethod "getAutoReverse" o = Clutter.Timeline.TimelineGetAutoReverseMethodInfo
    ResolvePropertyTransitionMethod "getCubicBezierProgress" o = Clutter.Timeline.TimelineGetCubicBezierProgressMethodInfo
    ResolvePropertyTransitionMethod "getCurrentRepeat" o = Clutter.Timeline.TimelineGetCurrentRepeatMethodInfo
    ResolvePropertyTransitionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolvePropertyTransitionMethod "getDelay" o = Clutter.Timeline.TimelineGetDelayMethodInfo
    ResolvePropertyTransitionMethod "getDelta" o = Clutter.Timeline.TimelineGetDeltaMethodInfo
    ResolvePropertyTransitionMethod "getDirection" o = Clutter.Timeline.TimelineGetDirectionMethodInfo
    ResolvePropertyTransitionMethod "getDuration" o = Clutter.Timeline.TimelineGetDurationMethodInfo
    ResolvePropertyTransitionMethod "getDurationHint" o = Clutter.Timeline.TimelineGetDurationHintMethodInfo
    ResolvePropertyTransitionMethod "getElapsedTime" o = Clutter.Timeline.TimelineGetElapsedTimeMethodInfo
    ResolvePropertyTransitionMethod "getId" o = Clutter.Scriptable.ScriptableGetIdMethodInfo
    ResolvePropertyTransitionMethod "getInterval" o = Clutter.Transition.TransitionGetIntervalMethodInfo
    ResolvePropertyTransitionMethod "getLoop" o = Clutter.Timeline.TimelineGetLoopMethodInfo
    ResolvePropertyTransitionMethod "getProgress" o = Clutter.Timeline.TimelineGetProgressMethodInfo
    ResolvePropertyTransitionMethod "getProgressMode" o = Clutter.Timeline.TimelineGetProgressModeMethodInfo
    ResolvePropertyTransitionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolvePropertyTransitionMethod "getPropertyName" o = PropertyTransitionGetPropertyNameMethodInfo
    ResolvePropertyTransitionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolvePropertyTransitionMethod "getRemoveOnComplete" o = Clutter.Transition.TransitionGetRemoveOnCompleteMethodInfo
    ResolvePropertyTransitionMethod "getRepeatCount" o = Clutter.Timeline.TimelineGetRepeatCountMethodInfo
    ResolvePropertyTransitionMethod "getStepProgress" o = Clutter.Timeline.TimelineGetStepProgressMethodInfo
    ResolvePropertyTransitionMethod "setAnimatable" o = Clutter.Transition.TransitionSetAnimatableMethodInfo
    ResolvePropertyTransitionMethod "setAutoReverse" o = Clutter.Timeline.TimelineSetAutoReverseMethodInfo
    ResolvePropertyTransitionMethod "setCubicBezierProgress" o = Clutter.Timeline.TimelineSetCubicBezierProgressMethodInfo
    ResolvePropertyTransitionMethod "setCustomProperty" o = Clutter.Scriptable.ScriptableSetCustomPropertyMethodInfo
    ResolvePropertyTransitionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolvePropertyTransitionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolvePropertyTransitionMethod "setDelay" o = Clutter.Timeline.TimelineSetDelayMethodInfo
    ResolvePropertyTransitionMethod "setDirection" o = Clutter.Timeline.TimelineSetDirectionMethodInfo
    ResolvePropertyTransitionMethod "setDuration" o = Clutter.Timeline.TimelineSetDurationMethodInfo
    ResolvePropertyTransitionMethod "setFrom" o = Clutter.Transition.TransitionSetFromMethodInfo
    ResolvePropertyTransitionMethod "setId" o = Clutter.Scriptable.ScriptableSetIdMethodInfo
    ResolvePropertyTransitionMethod "setInterval" o = Clutter.Transition.TransitionSetIntervalMethodInfo
    ResolvePropertyTransitionMethod "setLoop" o = Clutter.Timeline.TimelineSetLoopMethodInfo
    ResolvePropertyTransitionMethod "setProgressFunc" o = Clutter.Timeline.TimelineSetProgressFuncMethodInfo
    ResolvePropertyTransitionMethod "setProgressMode" o = Clutter.Timeline.TimelineSetProgressModeMethodInfo
    ResolvePropertyTransitionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolvePropertyTransitionMethod "setPropertyName" o = PropertyTransitionSetPropertyNameMethodInfo
    ResolvePropertyTransitionMethod "setRemoveOnComplete" o = Clutter.Transition.TransitionSetRemoveOnCompleteMethodInfo
    ResolvePropertyTransitionMethod "setRepeatCount" o = Clutter.Timeline.TimelineSetRepeatCountMethodInfo
    ResolvePropertyTransitionMethod "setStepProgress" o = Clutter.Timeline.TimelineSetStepProgressMethodInfo
    ResolvePropertyTransitionMethod "setTo" o = Clutter.Transition.TransitionSetToMethodInfo
    ResolvePropertyTransitionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolvePropertyTransitionMethod t PropertyTransition, O.OverloadedMethod info PropertyTransition p) => OL.IsLabel t (PropertyTransition -> 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 ~ ResolvePropertyTransitionMethod t PropertyTransition, O.OverloadedMethod info PropertyTransition p, R.HasField t PropertyTransition p) => R.HasField t PropertyTransition p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- VVV Prop "property-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

-- | Get the value of the “@property-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' propertyTransition #propertyName
-- @
getPropertyTransitionPropertyName :: (MonadIO m, IsPropertyTransition o) => o -> m T.Text
getPropertyTransitionPropertyName :: forall (m :: * -> *) o.
(MonadIO m, IsPropertyTransition o) =>
o -> m Text
getPropertyTransitionPropertyName o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getPropertyTransitionPropertyName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"property-name"

-- | Set the value of the “@property-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' propertyTransition [ #propertyName 'Data.GI.Base.Attributes.:=' value ]
-- @
setPropertyTransitionPropertyName :: (MonadIO m, IsPropertyTransition o) => o -> T.Text -> m ()
setPropertyTransitionPropertyName :: forall (m :: * -> *) o.
(MonadIO m, IsPropertyTransition o) =>
o -> Text -> m ()
setPropertyTransitionPropertyName o
obj Text
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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"property-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@property-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPropertyTransitionPropertyName :: (IsPropertyTransition o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructPropertyTransitionPropertyName :: forall o (m :: * -> *).
(IsPropertyTransition o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructPropertyTransitionPropertyName Text
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 Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"property-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@property-name@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #propertyName
-- @
clearPropertyTransitionPropertyName :: (MonadIO m, IsPropertyTransition o) => o -> m ()
clearPropertyTransitionPropertyName :: forall (m :: * -> *) o.
(MonadIO m, IsPropertyTransition o) =>
o -> m ()
clearPropertyTransitionPropertyName o
obj = 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
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"property-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data PropertyTransitionPropertyNamePropertyInfo
instance AttrInfo PropertyTransitionPropertyNamePropertyInfo where
    type AttrAllowedOps PropertyTransitionPropertyNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PropertyTransitionPropertyNamePropertyInfo = IsPropertyTransition
    type AttrSetTypeConstraint PropertyTransitionPropertyNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint PropertyTransitionPropertyNamePropertyInfo = (~) T.Text
    type AttrTransferType PropertyTransitionPropertyNamePropertyInfo = T.Text
    type AttrGetType PropertyTransitionPropertyNamePropertyInfo = T.Text
    type AttrLabel PropertyTransitionPropertyNamePropertyInfo = "property-name"
    type AttrOrigin PropertyTransitionPropertyNamePropertyInfo = PropertyTransition
    attrGet = getPropertyTransitionPropertyName
    attrSet = setPropertyTransitionPropertyName
    attrTransfer _ v = do
        return v
    attrConstruct = constructPropertyTransitionPropertyName
    attrClear = clearPropertyTransitionPropertyName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PropertyTransition.propertyName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PropertyTransition.html#g:attr:propertyName"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PropertyTransition
type instance O.AttributeList PropertyTransition = PropertyTransitionAttributeList
type PropertyTransitionAttributeList = ('[ '("animatable", Clutter.Transition.TransitionAnimatablePropertyInfo), '("autoReverse", Clutter.Timeline.TimelineAutoReversePropertyInfo), '("delay", Clutter.Timeline.TimelineDelayPropertyInfo), '("direction", Clutter.Timeline.TimelineDirectionPropertyInfo), '("duration", Clutter.Timeline.TimelineDurationPropertyInfo), '("interval", Clutter.Transition.TransitionIntervalPropertyInfo), '("loop", Clutter.Timeline.TimelineLoopPropertyInfo), '("progressMode", Clutter.Timeline.TimelineProgressModePropertyInfo), '("propertyName", PropertyTransitionPropertyNamePropertyInfo), '("removeOnComplete", Clutter.Transition.TransitionRemoveOnCompletePropertyInfo), '("repeatCount", Clutter.Timeline.TimelineRepeatCountPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
propertyTransitionPropertyName :: AttrLabelProxy "propertyName"
propertyTransitionPropertyName = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList PropertyTransition = PropertyTransitionSignalList
type PropertyTransitionSignalList = ('[ '("completed", Clutter.Timeline.TimelineCompletedSignalInfo), '("markerReached", Clutter.Timeline.TimelineMarkerReachedSignalInfo), '("newFrame", Clutter.Timeline.TimelineNewFrameSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paused", Clutter.Timeline.TimelinePausedSignalInfo), '("started", Clutter.Timeline.TimelineStartedSignalInfo), '("stopped", Clutter.Timeline.TimelineStoppedSignalInfo)] :: [(Symbol, *)])

#endif

-- method PropertyTransition::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a property of @animatable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "PropertyTransition" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_property_transition_new" clutter_property_transition_new :: 
    CString ->                              -- property_name : TBasicType TUTF8
    IO (Ptr PropertyTransition)

-- | Creates a new t'GI.Clutter.Objects.PropertyTransition.PropertyTransition'.
-- 
-- /Since: 1.10/
propertyTransitionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    -- ^ /@propertyName@/: a property of /@animatable@/, or 'P.Nothing'
    -> m PropertyTransition
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.PropertyTransition.PropertyTransition'.
    --   Use 'GI.GObject.Objects.Object.objectUnref' when done
propertyTransitionNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m PropertyTransition
propertyTransitionNew Maybe Text
propertyName = IO PropertyTransition -> m PropertyTransition
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PropertyTransition -> m PropertyTransition)
-> IO PropertyTransition -> m PropertyTransition
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
maybePropertyName <- case Maybe Text
propertyName of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jPropertyName -> do
            Ptr CChar
jPropertyName' <- Text -> IO (Ptr CChar)
textToCString Text
jPropertyName
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jPropertyName'
    Ptr PropertyTransition
result <- Ptr CChar -> IO (Ptr PropertyTransition)
clutter_property_transition_new Ptr CChar
maybePropertyName
    Text -> Ptr PropertyTransition -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"propertyTransitionNew" Ptr PropertyTransition
result
    PropertyTransition
result' <- ((ManagedPtr PropertyTransition -> PropertyTransition)
-> Ptr PropertyTransition -> IO PropertyTransition
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PropertyTransition -> PropertyTransition
PropertyTransition) Ptr PropertyTransition
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybePropertyName
    PropertyTransition -> IO PropertyTransition
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PropertyTransition
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PropertyTransition::get_property_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "transition"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "PropertyTransition" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPropertyTransition"
--                 , 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_property_transition_get_property_name" clutter_property_transition_get_property_name :: 
    Ptr PropertyTransition ->               -- transition : TInterface (Name {namespace = "Clutter", name = "PropertyTransition"})
    IO CString

-- | Retrieves the value of the [PropertyTransition:propertyName]("GI.Clutter.Objects.PropertyTransition#g:attr:propertyName")
-- property.
-- 
-- /Since: 1.10/
propertyTransitionGetPropertyName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPropertyTransition a) =>
    a
    -- ^ /@transition@/: a t'GI.Clutter.Objects.PropertyTransition.PropertyTransition'
    -> m T.Text
    -- ^ __Returns:__ the name of the property being animated, or 'P.Nothing' if
    --   none is set. The returned string is owned by the /@transition@/ and
    --   it should not be freed.
propertyTransitionGetPropertyName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPropertyTransition a) =>
a -> m Text
propertyTransitionGetPropertyName a
transition = IO Text -> m Text
forall a. IO a -> m a
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 PropertyTransition
transition' <- a -> IO (Ptr PropertyTransition)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
transition
    Ptr CChar
result <- Ptr PropertyTransition -> IO (Ptr CChar)
clutter_property_transition_get_property_name Ptr PropertyTransition
transition'
    Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"propertyTransitionGetPropertyName" Ptr CChar
result
    Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
transition
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data PropertyTransitionGetPropertyNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPropertyTransition a) => O.OverloadedMethod PropertyTransitionGetPropertyNameMethodInfo a signature where
    overloadedMethod = propertyTransitionGetPropertyName

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


#endif

-- method PropertyTransition::set_property_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "transition"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "PropertyTransition" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPropertyTransition"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a property name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_property_transition_set_property_name" clutter_property_transition_set_property_name :: 
    Ptr PropertyTransition ->               -- transition : TInterface (Name {namespace = "Clutter", name = "PropertyTransition"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO ()

-- | Sets the [PropertyTransition:propertyName]("GI.Clutter.Objects.PropertyTransition#g:attr:propertyName") property of /@transition@/.
-- 
-- /Since: 1.10/
propertyTransitionSetPropertyName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPropertyTransition a) =>
    a
    -- ^ /@transition@/: a t'GI.Clutter.Objects.PropertyTransition.PropertyTransition'
    -> Maybe (T.Text)
    -- ^ /@propertyName@/: a property name
    -> m ()
propertyTransitionSetPropertyName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPropertyTransition a) =>
a -> Maybe Text -> m ()
propertyTransitionSetPropertyName a
transition Maybe Text
propertyName = 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 PropertyTransition
transition' <- a -> IO (Ptr PropertyTransition)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
transition
    Ptr CChar
maybePropertyName <- case Maybe Text
propertyName of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jPropertyName -> do
            Ptr CChar
jPropertyName' <- Text -> IO (Ptr CChar)
textToCString Text
jPropertyName
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jPropertyName'
    Ptr PropertyTransition -> Ptr CChar -> IO ()
clutter_property_transition_set_property_name Ptr PropertyTransition
transition' Ptr CChar
maybePropertyName
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
transition
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybePropertyName
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PropertyTransitionSetPropertyNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPropertyTransition a) => O.OverloadedMethod PropertyTransitionSetPropertyNameMethodInfo a signature where
    overloadedMethod = propertyTransitionSetPropertyName

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


#endif