{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect' is an opaque structure
-- whose members can only be accessed using the provided API
-- 
-- /Since: 1.4/

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

module GI.Clutter.Objects.PageTurnEffect
    ( 

-- * Exported types
    PageTurnEffect(..)                      ,
    IsPageTurnEffect                        ,
    toPageTurnEffect                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [createTexture]("GI.Clutter.Objects.OffscreenEffect#g:method:createTexture"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [invalidate]("GI.Clutter.Objects.DeformEffect#g:method:invalidate"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paintTarget]("GI.Clutter.Objects.OffscreenEffect#g:method:paintTarget"), [queueRepaint]("GI.Clutter.Objects.Effect#g:method:queueRepaint"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getActor]("GI.Clutter.Objects.ActorMeta#g:method:getActor"), [getAngle]("GI.Clutter.Objects.PageTurnEffect#g:method:getAngle"), [getBackMaterial]("GI.Clutter.Objects.DeformEffect#g:method:getBackMaterial"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getEnabled]("GI.Clutter.Objects.ActorMeta#g:method:getEnabled"), [getNTiles]("GI.Clutter.Objects.DeformEffect#g:method:getNTiles"), [getName]("GI.Clutter.Objects.ActorMeta#g:method:getName"), [getPeriod]("GI.Clutter.Objects.PageTurnEffect#g:method:getPeriod"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRadius]("GI.Clutter.Objects.PageTurnEffect#g:method:getRadius"), [getTarget]("GI.Clutter.Objects.OffscreenEffect#g:method:getTarget"), [getTargetRect]("GI.Clutter.Objects.OffscreenEffect#g:method:getTargetRect"), [getTargetSize]("GI.Clutter.Objects.OffscreenEffect#g:method:getTargetSize"), [getTexture]("GI.Clutter.Objects.OffscreenEffect#g:method:getTexture").
-- 
-- ==== Setters
-- [setAngle]("GI.Clutter.Objects.PageTurnEffect#g:method:setAngle"), [setBackMaterial]("GI.Clutter.Objects.DeformEffect#g:method:setBackMaterial"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setEnabled]("GI.Clutter.Objects.ActorMeta#g:method:setEnabled"), [setNTiles]("GI.Clutter.Objects.DeformEffect#g:method:setNTiles"), [setName]("GI.Clutter.Objects.ActorMeta#g:method:setName"), [setPeriod]("GI.Clutter.Objects.PageTurnEffect#g:method:setPeriod"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRadius]("GI.Clutter.Objects.PageTurnEffect#g:method:setRadius").

#if defined(ENABLE_OVERLOADING)
    ResolvePageTurnEffectMethod             ,
#endif

-- ** getAngle #method:getAngle#

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectGetAngleMethodInfo        ,
#endif
    pageTurnEffectGetAngle                  ,


-- ** getPeriod #method:getPeriod#

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectGetPeriodMethodInfo       ,
#endif
    pageTurnEffectGetPeriod                 ,


-- ** getRadius #method:getRadius#

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectGetRadiusMethodInfo       ,
#endif
    pageTurnEffectGetRadius                 ,


-- ** new #method:new#

    pageTurnEffectNew                       ,


-- ** setAngle #method:setAngle#

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectSetAngleMethodInfo        ,
#endif
    pageTurnEffectSetAngle                  ,


-- ** setPeriod #method:setPeriod#

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectSetPeriodMethodInfo       ,
#endif
    pageTurnEffectSetPeriod                 ,


-- ** setRadius #method:setRadius#

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectSetRadiusMethodInfo       ,
#endif
    pageTurnEffectSetRadius                 ,




 -- * Properties


-- ** angle #attr:angle#
-- | The angle of the page rotation, in degrees, between 0.0 and 360.0
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectAnglePropertyInfo         ,
#endif
    constructPageTurnEffectAngle            ,
    getPageTurnEffectAngle                  ,
#if defined(ENABLE_OVERLOADING)
    pageTurnEffectAngle                     ,
#endif
    setPageTurnEffectAngle                  ,


-- ** period #attr:period#
-- | The period of the page turn, between 0.0 (no curling) and
-- 1.0 (fully curled)
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectPeriodPropertyInfo        ,
#endif
    constructPageTurnEffectPeriod           ,
    getPageTurnEffectPeriod                 ,
#if defined(ENABLE_OVERLOADING)
    pageTurnEffectPeriod                    ,
#endif
    setPageTurnEffectPeriod                 ,


-- ** radius #attr:radius#
-- | The radius of the page curl, in pixels
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    PageTurnEffectRadiusPropertyInfo        ,
#endif
    constructPageTurnEffectRadius           ,
    getPageTurnEffectRadius                 ,
#if defined(ENABLE_OVERLOADING)
    pageTurnEffectRadius                    ,
#endif
    setPageTurnEffectRadius                 ,




    ) 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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.RectangleInt as Cairo.RectangleInt
import qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Content as Clutter.Content
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Alpha as Clutter.Alpha
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animation as Clutter.Animation
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animator as Clutter.Animator
import {-# SOURCE #-} qualified GI.Clutter.Objects.Backend as Clutter.Backend
import {-# SOURCE #-} qualified GI.Clutter.Objects.ChildMeta as Clutter.ChildMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Constraint as Clutter.Constraint
import {-# SOURCE #-} qualified GI.Clutter.Objects.DeformEffect as Clutter.DeformEffect
import {-# SOURCE #-} qualified GI.Clutter.Objects.DeviceManager as Clutter.DeviceManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.Group as Clutter.Group
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Interval as Clutter.Interval
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutManager as Clutter.LayoutManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutMeta as Clutter.LayoutMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.OffscreenEffect as Clutter.OffscreenEffect
import {-# SOURCE #-} qualified GI.Clutter.Objects.Script as Clutter.Script
import {-# SOURCE #-} qualified GI.Clutter.Objects.Shader as Clutter.Shader
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Objects.State as Clutter.State
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import {-# SOURCE #-} qualified GI.Clutter.Objects.Transition as Clutter.Transition
import {-# SOURCE #-} qualified GI.Clutter.Structs.ActorBox as Clutter.ActorBox
import {-# SOURCE #-} qualified GI.Clutter.Structs.AnimatorKey as Clutter.AnimatorKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.ButtonEvent as Clutter.ButtonEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.CrossingEvent as Clutter.CrossingEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.EventSequence as Clutter.EventSequence
import {-# SOURCE #-} qualified GI.Clutter.Structs.Fog as Clutter.Fog
import {-# SOURCE #-} qualified GI.Clutter.Structs.Geometry as Clutter.Geometry
import {-# SOURCE #-} qualified GI.Clutter.Structs.KeyEvent as Clutter.KeyEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Margin as Clutter.Margin
import {-# SOURCE #-} qualified GI.Clutter.Structs.Matrix as Clutter.Matrix
import {-# SOURCE #-} qualified GI.Clutter.Structs.MotionEvent as Clutter.MotionEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.PaintVolume as Clutter.PaintVolume
import {-# SOURCE #-} qualified GI.Clutter.Structs.Perspective as Clutter.Perspective
import {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import {-# SOURCE #-} qualified GI.Clutter.Structs.ScrollEvent as Clutter.ScrollEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Size as Clutter.Size
import {-# SOURCE #-} qualified GI.Clutter.Structs.StateKey as Clutter.StateKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.Vertex as Clutter.Vertex
import {-# SOURCE #-} qualified GI.Clutter.Unions.Event as Clutter.Event
import qualified GI.Cogl.Structs.Material as Cogl.Material
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Json.Structs.Node as Json.Node
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.Layout as Pango.Layout

#else
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.DeformEffect as Clutter.DeformEffect
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.OffscreenEffect as Clutter.OffscreenEffect
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

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

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

foreign import ccall "clutter_page_turn_effect_get_type"
    c_clutter_page_turn_effect_get_type :: IO B.Types.GType

instance B.Types.TypedObject PageTurnEffect where
    glibType :: IO GType
glibType = IO GType
c_clutter_page_turn_effect_get_type

instance B.Types.GObject PageTurnEffect

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

instance O.HasParentTypes PageTurnEffect
type instance O.ParentTypes PageTurnEffect = '[Clutter.DeformEffect.DeformEffect, Clutter.OffscreenEffect.OffscreenEffect, Clutter.Effect.Effect, Clutter.ActorMeta.ActorMeta, GObject.Object.Object]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolvePageTurnEffectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePageTurnEffectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolvePageTurnEffectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolvePageTurnEffectMethod "createTexture" o = Clutter.OffscreenEffect.OffscreenEffectCreateTextureMethodInfo
    ResolvePageTurnEffectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolvePageTurnEffectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolvePageTurnEffectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolvePageTurnEffectMethod "invalidate" o = Clutter.DeformEffect.DeformEffectInvalidateMethodInfo
    ResolvePageTurnEffectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolvePageTurnEffectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolvePageTurnEffectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolvePageTurnEffectMethod "paintTarget" o = Clutter.OffscreenEffect.OffscreenEffectPaintTargetMethodInfo
    ResolvePageTurnEffectMethod "queueRepaint" o = Clutter.Effect.EffectQueueRepaintMethodInfo
    ResolvePageTurnEffectMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolvePageTurnEffectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolvePageTurnEffectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolvePageTurnEffectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolvePageTurnEffectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolvePageTurnEffectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolvePageTurnEffectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolvePageTurnEffectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolvePageTurnEffectMethod "getActor" o = Clutter.ActorMeta.ActorMetaGetActorMethodInfo
    ResolvePageTurnEffectMethod "getAngle" o = PageTurnEffectGetAngleMethodInfo
    ResolvePageTurnEffectMethod "getBackMaterial" o = Clutter.DeformEffect.DeformEffectGetBackMaterialMethodInfo
    ResolvePageTurnEffectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolvePageTurnEffectMethod "getEnabled" o = Clutter.ActorMeta.ActorMetaGetEnabledMethodInfo
    ResolvePageTurnEffectMethod "getNTiles" o = Clutter.DeformEffect.DeformEffectGetNTilesMethodInfo
    ResolvePageTurnEffectMethod "getName" o = Clutter.ActorMeta.ActorMetaGetNameMethodInfo
    ResolvePageTurnEffectMethod "getPeriod" o = PageTurnEffectGetPeriodMethodInfo
    ResolvePageTurnEffectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolvePageTurnEffectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolvePageTurnEffectMethod "getRadius" o = PageTurnEffectGetRadiusMethodInfo
    ResolvePageTurnEffectMethod "getTarget" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetMethodInfo
    ResolvePageTurnEffectMethod "getTargetRect" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetRectMethodInfo
    ResolvePageTurnEffectMethod "getTargetSize" o = Clutter.OffscreenEffect.OffscreenEffectGetTargetSizeMethodInfo
    ResolvePageTurnEffectMethod "getTexture" o = Clutter.OffscreenEffect.OffscreenEffectGetTextureMethodInfo
    ResolvePageTurnEffectMethod "setAngle" o = PageTurnEffectSetAngleMethodInfo
    ResolvePageTurnEffectMethod "setBackMaterial" o = Clutter.DeformEffect.DeformEffectSetBackMaterialMethodInfo
    ResolvePageTurnEffectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolvePageTurnEffectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolvePageTurnEffectMethod "setEnabled" o = Clutter.ActorMeta.ActorMetaSetEnabledMethodInfo
    ResolvePageTurnEffectMethod "setNTiles" o = Clutter.DeformEffect.DeformEffectSetNTilesMethodInfo
    ResolvePageTurnEffectMethod "setName" o = Clutter.ActorMeta.ActorMetaSetNameMethodInfo
    ResolvePageTurnEffectMethod "setPeriod" o = PageTurnEffectSetPeriodMethodInfo
    ResolvePageTurnEffectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolvePageTurnEffectMethod "setRadius" o = PageTurnEffectSetRadiusMethodInfo
    ResolvePageTurnEffectMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- VVV Prop "angle"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@angle@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTurnEffect #angle
-- @
getPageTurnEffectAngle :: (MonadIO m, IsPageTurnEffect o) => o -> m Double
getPageTurnEffectAngle :: forall (m :: * -> *) o.
(MonadIO m, IsPageTurnEffect o) =>
o -> m Double
getPageTurnEffectAngle 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
"angle"

-- | Set the value of the “@angle@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTurnEffect [ #angle 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTurnEffectAngle :: (MonadIO m, IsPageTurnEffect o) => o -> Double -> m ()
setPageTurnEffectAngle :: forall (m :: * -> *) o.
(MonadIO m, IsPageTurnEffect o) =>
o -> Double -> m ()
setPageTurnEffectAngle o
obj Double
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 -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"angle" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@angle@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPageTurnEffectAngle :: (IsPageTurnEffect o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructPageTurnEffectAngle :: forall o (m :: * -> *).
(IsPageTurnEffect o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructPageTurnEffectAngle Double
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 -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"angle" Double
val

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectAnglePropertyInfo
instance AttrInfo PageTurnEffectAnglePropertyInfo where
    type AttrAllowedOps PageTurnEffectAnglePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PageTurnEffectAnglePropertyInfo = IsPageTurnEffect
    type AttrSetTypeConstraint PageTurnEffectAnglePropertyInfo = (~) Double
    type AttrTransferTypeConstraint PageTurnEffectAnglePropertyInfo = (~) Double
    type AttrTransferType PageTurnEffectAnglePropertyInfo = Double
    type AttrGetType PageTurnEffectAnglePropertyInfo = Double
    type AttrLabel PageTurnEffectAnglePropertyInfo = "angle"
    type AttrOrigin PageTurnEffectAnglePropertyInfo = PageTurnEffect
    attrGet = getPageTurnEffectAngle
    attrSet = setPageTurnEffectAngle
    attrTransfer _ v = do
        return v
    attrConstruct = constructPageTurnEffectAngle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PageTurnEffect.angle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-PageTurnEffect.html#g:attr:angle"
        })
#endif

-- VVV Prop "period"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@period@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTurnEffect #period
-- @
getPageTurnEffectPeriod :: (MonadIO m, IsPageTurnEffect o) => o -> m Double
getPageTurnEffectPeriod :: forall (m :: * -> *) o.
(MonadIO m, IsPageTurnEffect o) =>
o -> m Double
getPageTurnEffectPeriod 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
"period"

-- | Set the value of the “@period@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTurnEffect [ #period 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTurnEffectPeriod :: (MonadIO m, IsPageTurnEffect o) => o -> Double -> m ()
setPageTurnEffectPeriod :: forall (m :: * -> *) o.
(MonadIO m, IsPageTurnEffect o) =>
o -> Double -> m ()
setPageTurnEffectPeriod o
obj Double
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 -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"period" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@period@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPageTurnEffectPeriod :: (IsPageTurnEffect o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructPageTurnEffectPeriod :: forall o (m :: * -> *).
(IsPageTurnEffect o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructPageTurnEffectPeriod Double
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 -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"period" Double
val

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectPeriodPropertyInfo
instance AttrInfo PageTurnEffectPeriodPropertyInfo where
    type AttrAllowedOps PageTurnEffectPeriodPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PageTurnEffectPeriodPropertyInfo = IsPageTurnEffect
    type AttrSetTypeConstraint PageTurnEffectPeriodPropertyInfo = (~) Double
    type AttrTransferTypeConstraint PageTurnEffectPeriodPropertyInfo = (~) Double
    type AttrTransferType PageTurnEffectPeriodPropertyInfo = Double
    type AttrGetType PageTurnEffectPeriodPropertyInfo = Double
    type AttrLabel PageTurnEffectPeriodPropertyInfo = "period"
    type AttrOrigin PageTurnEffectPeriodPropertyInfo = PageTurnEffect
    attrGet = getPageTurnEffectPeriod
    attrSet = setPageTurnEffectPeriod
    attrTransfer _ v = do
        return v
    attrConstruct = constructPageTurnEffectPeriod
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PageTurnEffect.period"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-PageTurnEffect.html#g:attr:period"
        })
#endif

-- VVV Prop "radius"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@radius@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTurnEffect #radius
-- @
getPageTurnEffectRadius :: (MonadIO m, IsPageTurnEffect o) => o -> m Float
getPageTurnEffectRadius :: forall (m :: * -> *) o.
(MonadIO m, IsPageTurnEffect o) =>
o -> m Float
getPageTurnEffectRadius o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"radius"

-- | Set the value of the “@radius@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTurnEffect [ #radius 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTurnEffectRadius :: (MonadIO m, IsPageTurnEffect o) => o -> Float -> m ()
setPageTurnEffectRadius :: forall (m :: * -> *) o.
(MonadIO m, IsPageTurnEffect o) =>
o -> Float -> m ()
setPageTurnEffectRadius o
obj Float
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 -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"radius" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@radius@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPageTurnEffectRadius :: (IsPageTurnEffect o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructPageTurnEffectRadius :: forall o (m :: * -> *).
(IsPageTurnEffect o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructPageTurnEffectRadius Float
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 -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"radius" Float
val

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectRadiusPropertyInfo
instance AttrInfo PageTurnEffectRadiusPropertyInfo where
    type AttrAllowedOps PageTurnEffectRadiusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PageTurnEffectRadiusPropertyInfo = IsPageTurnEffect
    type AttrSetTypeConstraint PageTurnEffectRadiusPropertyInfo = (~) Float
    type AttrTransferTypeConstraint PageTurnEffectRadiusPropertyInfo = (~) Float
    type AttrTransferType PageTurnEffectRadiusPropertyInfo = Float
    type AttrGetType PageTurnEffectRadiusPropertyInfo = Float
    type AttrLabel PageTurnEffectRadiusPropertyInfo = "radius"
    type AttrOrigin PageTurnEffectRadiusPropertyInfo = PageTurnEffect
    attrGet = getPageTurnEffectRadius
    attrSet = setPageTurnEffectRadius
    attrTransfer _ v = do
        return v
    attrConstruct = constructPageTurnEffectRadius
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PageTurnEffect.radius"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-PageTurnEffect.html#g:attr:radius"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PageTurnEffect
type instance O.AttributeList PageTurnEffect = PageTurnEffectAttributeList
type PageTurnEffectAttributeList = ('[ '("actor", Clutter.ActorMeta.ActorMetaActorPropertyInfo), '("angle", PageTurnEffectAnglePropertyInfo), '("enabled", Clutter.ActorMeta.ActorMetaEnabledPropertyInfo), '("name", Clutter.ActorMeta.ActorMetaNamePropertyInfo), '("period", PageTurnEffectPeriodPropertyInfo), '("radius", PageTurnEffectRadiusPropertyInfo), '("xTiles", Clutter.DeformEffect.DeformEffectXTilesPropertyInfo), '("yTiles", Clutter.DeformEffect.DeformEffectYTilesPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
pageTurnEffectAngle :: AttrLabelProxy "angle"
pageTurnEffectAngle = AttrLabelProxy

pageTurnEffectPeriod :: AttrLabelProxy "period"
pageTurnEffectPeriod = AttrLabelProxy

pageTurnEffectRadius :: AttrLabelProxy "radius"
pageTurnEffectRadius = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList PageTurnEffect = PageTurnEffectSignalList
type PageTurnEffectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method PageTurnEffect::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "period"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the period of the page curl, between 0.0 and 1.0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the angle of the page curl, between 0.0 and 360.0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "radius"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the radius of the page curl, in pixels"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "PageTurnEffect" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_page_turn_effect_new" clutter_page_turn_effect_new :: 
    CDouble ->                              -- period : TBasicType TDouble
    CDouble ->                              -- angle : TBasicType TDouble
    CFloat ->                               -- radius : TBasicType TFloat
    IO (Ptr PageTurnEffect)

-- | Creates a new t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect' instance with the given parameters
-- 
-- /Since: 1.4/
pageTurnEffectNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Double
    -- ^ /@period@/: the period of the page curl, between 0.0 and 1.0
    -> Double
    -- ^ /@angle@/: the angle of the page curl, between 0.0 and 360.0
    -> Float
    -- ^ /@radius@/: the radius of the page curl, in pixels
    -> m PageTurnEffect
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect'
pageTurnEffectNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Double -> Double -> Float -> m PageTurnEffect
pageTurnEffectNew Double
period Double
angle Float
radius = IO PageTurnEffect -> m PageTurnEffect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PageTurnEffect -> m PageTurnEffect)
-> IO PageTurnEffect -> m PageTurnEffect
forall a b. (a -> b) -> a -> b
$ do
    let period' :: CDouble
period' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
period
    let angle' :: CDouble
angle' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
angle
    let radius' :: CFloat
radius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
radius
    Ptr PageTurnEffect
result <- CDouble -> CDouble -> CFloat -> IO (Ptr PageTurnEffect)
clutter_page_turn_effect_new CDouble
period' CDouble
angle' CFloat
radius'
    Text -> Ptr PageTurnEffect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pageTurnEffectNew" Ptr PageTurnEffect
result
    PageTurnEffect
result' <- ((ManagedPtr PageTurnEffect -> PageTurnEffect)
-> Ptr PageTurnEffect -> IO PageTurnEffect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PageTurnEffect -> PageTurnEffect
PageTurnEffect) Ptr PageTurnEffect
result
    PageTurnEffect -> IO PageTurnEffect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PageTurnEffect
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "clutter_page_turn_effect_get_angle" clutter_page_turn_effect_get_angle :: 
    Ptr PageTurnEffect ->                   -- effect : TInterface (Name {namespace = "Clutter", name = "PageTurnEffect"})
    IO CDouble

-- | Retrieves the value set using 'GI.Clutter.Objects.PageTurnEffect.pageTurnEffectGetAngle'
-- 
-- /Since: 1.4/
pageTurnEffectGetAngle ::
    (B.CallStack.HasCallStack, MonadIO m, IsPageTurnEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect':
    -> m Double
    -- ^ __Returns:__ the angle of the page curling
pageTurnEffectGetAngle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPageTurnEffect a) =>
a -> m Double
pageTurnEffectGetAngle a
effect = 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 PageTurnEffect
effect' <- a -> IO (Ptr PageTurnEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    CDouble
result <- Ptr PageTurnEffect -> IO CDouble
clutter_page_turn_effect_get_angle Ptr PageTurnEffect
effect'
    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
effect
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectGetAngleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsPageTurnEffect a) => O.OverloadedMethod PageTurnEffectGetAngleMethodInfo a signature where
    overloadedMethod = pageTurnEffectGetAngle

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


#endif

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

foreign import ccall "clutter_page_turn_effect_get_period" clutter_page_turn_effect_get_period :: 
    Ptr PageTurnEffect ->                   -- effect : TInterface (Name {namespace = "Clutter", name = "PageTurnEffect"})
    IO CDouble

-- | Retrieves the value set using 'GI.Clutter.Objects.PageTurnEffect.pageTurnEffectGetPeriod'
-- 
-- /Since: 1.4/
pageTurnEffectGetPeriod ::
    (B.CallStack.HasCallStack, MonadIO m, IsPageTurnEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect'
    -> m Double
    -- ^ __Returns:__ the period of the page curling
pageTurnEffectGetPeriod :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPageTurnEffect a) =>
a -> m Double
pageTurnEffectGetPeriod a
effect = 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 PageTurnEffect
effect' <- a -> IO (Ptr PageTurnEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    CDouble
result <- Ptr PageTurnEffect -> IO CDouble
clutter_page_turn_effect_get_period Ptr PageTurnEffect
effect'
    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
effect
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectGetPeriodMethodInfo
instance (signature ~ (m Double), MonadIO m, IsPageTurnEffect a) => O.OverloadedMethod PageTurnEffectGetPeriodMethodInfo a signature where
    overloadedMethod = pageTurnEffectGetPeriod

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


#endif

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

foreign import ccall "clutter_page_turn_effect_get_radius" clutter_page_turn_effect_get_radius :: 
    Ptr PageTurnEffect ->                   -- effect : TInterface (Name {namespace = "Clutter", name = "PageTurnEffect"})
    IO CFloat

-- | Retrieves the value set using 'GI.Clutter.Objects.PageTurnEffect.pageTurnEffectSetRadius'
-- 
-- /Since: 1.4/
pageTurnEffectGetRadius ::
    (B.CallStack.HasCallStack, MonadIO m, IsPageTurnEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect'
    -> m Float
    -- ^ __Returns:__ the radius of the page curling
pageTurnEffectGetRadius :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPageTurnEffect a) =>
a -> m Float
pageTurnEffectGetRadius a
effect = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr PageTurnEffect
effect' <- a -> IO (Ptr PageTurnEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    CFloat
result <- Ptr PageTurnEffect -> IO CFloat
clutter_page_turn_effect_get_radius Ptr PageTurnEffect
effect'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectGetRadiusMethodInfo
instance (signature ~ (m Float), MonadIO m, IsPageTurnEffect a) => O.OverloadedMethod PageTurnEffectGetRadiusMethodInfo a signature where
    overloadedMethod = pageTurnEffectGetRadius

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


#endif

-- method PageTurnEffect::set_angle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PageTurnEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#ClutterPageTurnEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the angle of the page curl, in degrees"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_page_turn_effect_set_angle" clutter_page_turn_effect_set_angle :: 
    Ptr PageTurnEffect ->                   -- effect : TInterface (Name {namespace = "Clutter", name = "PageTurnEffect"})
    CDouble ->                              -- angle : TBasicType TDouble
    IO ()

-- | Sets the angle of the page curling, in degrees
-- 
-- /Since: 1.4/
pageTurnEffectSetAngle ::
    (B.CallStack.HasCallStack, MonadIO m, IsPageTurnEffect a) =>
    a
    -- ^ /@effect@/: t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect'
    -> Double
    -- ^ /@angle@/: the angle of the page curl, in degrees
    -> m ()
pageTurnEffectSetAngle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPageTurnEffect a) =>
a -> Double -> m ()
pageTurnEffectSetAngle a
effect Double
angle = 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 PageTurnEffect
effect' <- a -> IO (Ptr PageTurnEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    let angle' :: CDouble
angle' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
angle
    Ptr PageTurnEffect -> CDouble -> IO ()
clutter_page_turn_effect_set_angle Ptr PageTurnEffect
effect' CDouble
angle'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectSetAngleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsPageTurnEffect a) => O.OverloadedMethod PageTurnEffectSetAngleMethodInfo a signature where
    overloadedMethod = pageTurnEffectSetAngle

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


#endif

-- method PageTurnEffect::set_period
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PageTurnEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPageTurnEffect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "period"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the period of the page curl, between 0.0 and 1.0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_page_turn_effect_set_period" clutter_page_turn_effect_set_period :: 
    Ptr PageTurnEffect ->                   -- effect : TInterface (Name {namespace = "Clutter", name = "PageTurnEffect"})
    CDouble ->                              -- period : TBasicType TDouble
    IO ()

-- | Sets the period of the page curling, between 0.0 (no curling)
-- and 1.0 (fully curled)
-- 
-- /Since: 1.4/
pageTurnEffectSetPeriod ::
    (B.CallStack.HasCallStack, MonadIO m, IsPageTurnEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect'
    -> Double
    -- ^ /@period@/: the period of the page curl, between 0.0 and 1.0
    -> m ()
pageTurnEffectSetPeriod :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPageTurnEffect a) =>
a -> Double -> m ()
pageTurnEffectSetPeriod a
effect Double
period = 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 PageTurnEffect
effect' <- a -> IO (Ptr PageTurnEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    let period' :: CDouble
period' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
period
    Ptr PageTurnEffect -> CDouble -> IO ()
clutter_page_turn_effect_set_period Ptr PageTurnEffect
effect' CDouble
period'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectSetPeriodMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsPageTurnEffect a) => O.OverloadedMethod PageTurnEffectSetPeriodMethodInfo a signature where
    overloadedMethod = pageTurnEffectSetPeriod

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


#endif

-- method PageTurnEffect::set_radius
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PageTurnEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPageTurnEffect:"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "radius"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the radius of the page curling, in pixels"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_page_turn_effect_set_radius" clutter_page_turn_effect_set_radius :: 
    Ptr PageTurnEffect ->                   -- effect : TInterface (Name {namespace = "Clutter", name = "PageTurnEffect"})
    CFloat ->                               -- radius : TBasicType TFloat
    IO ()

-- | Sets the radius of the page curling
-- 
-- /Since: 1.4/
pageTurnEffectSetRadius ::
    (B.CallStack.HasCallStack, MonadIO m, IsPageTurnEffect a) =>
    a
    -- ^ /@effect@/: a t'GI.Clutter.Objects.PageTurnEffect.PageTurnEffect':
    -> Float
    -- ^ /@radius@/: the radius of the page curling, in pixels
    -> m ()
pageTurnEffectSetRadius :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPageTurnEffect a) =>
a -> Float -> m ()
pageTurnEffectSetRadius a
effect Float
radius = 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 PageTurnEffect
effect' <- a -> IO (Ptr PageTurnEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
effect
    let radius' :: CFloat
radius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
radius
    Ptr PageTurnEffect -> CFloat -> IO ()
clutter_page_turn_effect_set_radius Ptr PageTurnEffect
effect' CFloat
radius'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
effect
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PageTurnEffectSetRadiusMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsPageTurnEffect a) => O.OverloadedMethod PageTurnEffectSetRadiusMethodInfo a signature where
    overloadedMethod = pageTurnEffectSetRadius

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


#endif